home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / DDPLUS71.ZIP / RIPLINK.ZIP / RIPLINK.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1995-03-23  |  92.7 KB  |  3,103 lines
  1. {.$A+,B-,D+,E-,F+,G-,I+,L+,N-,O+,P-,Q-,R-,S-,T-,V+,X+,Y+}
  2. Unit RipLink;
  3. {.$D-,L-,Y-}
  4. {$F+,O+}
  5.  
  6. { RipLink(tm) - Version 1.21      - 03/22/1995 }
  7. { Copyright (C) 1995 by InterProgramming       }
  8. { All rights reserved.                         }
  9.  
  10. { RIPscrip is a Trademark of TeleGrafix Communications, Inc. }
  11.  
  12. { All graphics routines are contained in RIPLINK.PA1. }
  13. { All font tables are contained in RIPLINK.PA2.       }
  14. { Additional routines are in RIPLINK1.PAS.            }
  15.  
  16. {$DEFINE INTDRIV}        { Either INTDRIV or FONTFILE should be defined.  }
  17. {.$DEFINE FONTFILE}       { INTDRIV is the ALL model and FONTFILE is the   }
  18. {.$DEFINE TP55}           { EXT model.  The INT model is no longer         }
  19. {.$DEFINE TP6}            { supported.  MOUSE defines whether the mouse    }
  20. {$DEFINE MOUSE}           { is to be used or not.  DEBUGIT and DEBUGPAUSE  }
  21. {.$DEFINE DEBUGIT}        { are for debugging.  See the RIPscrip Parser    }
  22. {.$DEFINE DEBUGPAUSE}     { for additional info.  If DOUBLENUM is defined, }
  23. {.$DEFINE DOUBLENUM}      { then $N+,E+ must also be defined.  While the   }
  24. {.$N+,E+}                 { RIPscrip standard calls for Double Nums, we    }
  25. {.$DEFINE USEOPRO}        { found no noticible different and decided to go }
  26.                           { with Reals as the default because of the speed }
  27.                           { difference.  USEOPRO is for users of Turbo     }
  28.                           { Power's Object Professional.                   }
  29.  
  30. {Absolute coords - RipMouse.AddRegion}
  31.  
  32. interface
  33.  
  34. uses
  35.   Dos, Graph, RipLink1,
  36.   {$IFDEF USEOPRO}
  37.   OpCrt;
  38.   {$ELSE}
  39.   Crt;
  40.   {$ENDIF}
  41.  
  42. const
  43.   TheRIPCopyright = '  RIPlink(tm) - Copyright (C) 1995 by Thomas E. Morgan and InterProgramming, All Rights Reserved.  ';
  44.   TheRIPCopyright2= '  Portions Copyright 1995 by Thomas E. Morgan and InterProgramming  ';
  45.  
  46. {$IFDEF INTDRIV} CantHaveIntDrivAndFontFileBothDefined = 1; {$ENDIF}
  47. {$IFDEF FONTFILE}CantHaveIntDrivAndFontFileBothDefined = 1; {$ENDIF}
  48.  
  49.   AnsiMaxParams       = 5;  {maximum parameters for our ansi interpreter}
  50.   eNone               = 0;  {no command, ignore this char}
  51.   eChar               = 1;  {no command, process the char}
  52.   eGotoXY             = 2;  {absolute goto cursor position call}
  53.   eUp                 = 3;  {cursor up}
  54.   eDown               = 4;  {cursor down}
  55.   eRight              = 5;  {cursor right}
  56.   eLeft               = 6;  {cursor left}
  57.   eClearBelow         = 7;  {clear screen below cursor}
  58.   eClearAbove         = 8;  {clear screen above cursor}
  59.   eClearScreen        = 9;  {clear entire screen}
  60.   eClearEndofLine     = 10; {clear from cursor to end of line}
  61.   eClearStartOfLine   = 11; {clear from cursor to the start of line}
  62.   eClearLine          = 12; {clear entire line that cursor is on}
  63.   eSetMode            = 13; {set video mode}
  64.   eSetBackground      = 14; {set background attribute}
  65.   eSetForeground      = 15; {set foreground attribute}
  66.   eSetAttribute       = 16; {set video attribute (foreground and background)}
  67.   eSaveCursorPos      = 17; {save cursor position}
  68.   eRestoreCursorPos   = 18; {restore cursor position}
  69.   eDeviceStatusReport = 19; {report device status or cursor position}
  70.   eError              = 255;{indicates a parser error}
  71.   Escape              = #27;
  72.   LeftBracket         = #91;
  73.   Semicolon           = #59;
  74.   FormFeed            = #12;
  75.   iQueueSize          = 32;
  76.  
  77.   TextOffsetX : array[0..4] of Byte = ( 8, 7, 8, 7,16);
  78.   TextOffsetY : array[0..4] of Byte = ( 8, 8,14,14,14);
  79.   TextMaxX    : array[0..4] of Byte = (79,90,79,90,39);
  80.   TextMaxY    : array[0..4] of Byte = (42,42,24,24,24);
  81.  
  82. type
  83.   Str2          = string[2];
  84.   Str4          = string[4];
  85.   Str12         = string[12];
  86.   Str50         = string[50];
  87.  
  88.   fpt           = array[1..8] of byte;
  89.  
  90.   ParseStatus   = (None,Got_Excl,Got_Pipe,Got_Level,Got_SubLevel,Got_Command);
  91.   CharStatus    = (cNone,Pending,ContLine,Escaped);
  92.   LastCharStatus= (lNone,lChar,lCR,lLF,lPipe,lBackSlash,lExcl);
  93.  
  94.   MouseRegionRecord = record
  95.     x0,y0,x1,y1     : word;
  96.     invert,reset    : boolean;
  97.     thetext         : str50;
  98.   end; {61}
  99.  
  100.   QueueType = Array[1..255] of Char;
  101.   QueuePtr  = ^QueueType;
  102.  
  103.   AnsiParserType = (GotNone,GotEscape,GotBracket,GotSemiColon,GotParam,GotCommand);
  104.  
  105.   CommandRecord = record
  106.     Ch   : Char;
  107.     Cmd  : Byte;
  108.     X, Y : Byte;
  109.   end;
  110.  
  111.   RootPtr = ^Root;
  112.   Root = object
  113.     constructor Init;
  114.     destructor Done; virtual;
  115.   end;
  116.  
  117.   RipPtr = ^RipObj;
  118.   RipObj = object(Root)
  119.     {general}
  120.     TMaxX0, TMaxY0, TMaxX1, TMaxY1 : word;
  121.     DefColor      : word;
  122.     CurFont       : byte;
  123.     CurSize       : byte;
  124.     Metric        : MetricRec;
  125.     ClipB         : Pointer;
  126.     ClipSize      : word;
  127.     IconDir       : DirStr;
  128.     StatText      : String[79];
  129.     LocalRip      : boolean;
  130.     {$IFDEF FONTFILE}
  131.     charfile      : file;
  132.     FontPtr       : Pointer;
  133.     FontSize      : word;
  134.     DriverPtr     : Pointer;
  135.     {$ENDIF}
  136.     {button info}
  137.     ButPlainWidth, ButPlainHeight, ButOrientation, ButFlags,
  138.     ButBevelSize, ButLabelFore, ButLabelDropShadow, ButPlainHilite,
  139.     ButPlainShadow, ButPlainSurface, ButGroupNum, ButFlags2,
  140.     ButLabelUnderline, ButCorner : word;
  141.     {mouse}
  142.     {$IFDEF MOUSE}
  143.     MouseExist    : boolean;
  144.     IsMouseOn     : boolean;
  145.     LastStatus,           {used for CheckMouse}
  146.     LastX,                { " }
  147.     LastY         : word; { " }
  148.     RegionArray   : Array[1..128] of MouseRegionRecord;
  149.     LastButton    : Byte; {how many regions are there?}
  150.     Inverted      : byte; {which region is currently inverted}
  151.     CurRegion     : Byte; {temp var for CheckMouse}
  152.     CurButton     : Byte; {which button are we working with?}
  153.     KeyBuf        : Array[1..250] of Char; {Input Buffer}
  154.     KeyBufHead    : Byte;                  {Head of Input Buffer}
  155.     KeyBufTail    : Byte;                  {Tail of Input Buffer}
  156.     {$ENDIF}
  157.     {ansi parser}
  158.     QueueSize     : Byte;      {size of our queue}
  159.     aTextAttr     : Byte;      {set to Crt's TextAttr on Init}
  160.     QueueIndex    : Byte;      {current index into queue}
  161.     Queue         : QueuePtr;  {ptr to our queue}
  162.     Params        : Array[1..AnsiMaxParams] of String[5]; {parameter strings}
  163.     ParamInt      : Array[1..AnsiMaxParams] of Integer;   {params as ints}
  164.     ParamIndex    : Byte;           {last param's index}
  165.     Inverse       : Boolean;
  166.     Intense       : Boolean;
  167.     Blink         : Boolean;
  168.     Invis         : Boolean;
  169.     ParserState   : AnsiParserType;
  170.     {rip parser}
  171.     Level,SubLevel: byte;
  172.     command       : char;
  173.     firstcmd,
  174.     nextcommand,
  175.     commanddone,
  176.     didrip        : boolean;
  177.     pstat         : parsestatus;
  178.     cstat         : charstatus;
  179.     lstat         : lastcharstatus;
  180.     lastc         : char;
  181.     rBuffer       : Array[1..1024] of char;
  182.     bufcount      : word;
  183.     {text window}                     {char/color}
  184.     VirtualWindow : Array[0..90,0..42,0..1] of Byte;
  185.     TextX0        : byte;
  186.     TextY0        : byte;
  187.     TextX1        : byte;
  188.     TextY1        : byte;
  189.     TextSize      : byte; {8x8/7x8/8x14/7x14/16x14}
  190.     TextWrap      : boolean;
  191.     TextActive    : boolean;
  192.     TextClr       : byte; {color}
  193.     CursorX       : byte;
  194.     CursorY       : byte;
  195.     CursorSaveX   : byte;
  196.     CursorSaveY   : byte;
  197.     CursorOn      : boolean;
  198.     CmdRec        : CommandRecord; {for ansi parser}
  199.     TextFontFile  : File of CharMapRecord;
  200.     TextChar      : CharMapRecord;
  201.     {other}
  202.     {$IFDEF DEBUGIT}
  203.     log           : text;
  204.     {$ENDIF}
  205.  
  206.     constructor Init(userip : boolean;fontname:string);
  207.     procedure   RipTextWindow(x0,y0,x1,y1 : byte; wrap : boolean; size : byte);
  208.     procedure   RipViewPort(x0,y0,x1,y1 : word);
  209.     procedure   RipResetWindows;
  210.     procedure   RipEraseWindow;
  211.     procedure   RipEraseView;
  212.     procedure   RipGotoXY(x0,y0 : byte);
  213.     procedure   RipHome;
  214.     procedure   RipEraseEOL;
  215.     procedure   RipColor(clr : byte);
  216.     procedure   RipSetPalette(c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12,c13,c14,c15,c16 : word);
  217.     procedure   RipOnePalette(color,value : word);
  218.     procedure   RipWriteMode(mode : byte);
  219.     procedure   RipMove(x0,y0 : word);
  220.     procedure   RipText(instr : string);
  221.     procedure   RipTextXY(x0,y0 : word; instr : string);
  222.     procedure   RipFontStyle(font, direct, size : byte);
  223.     procedure   RipPixel(x0,y0 : word);
  224.     procedure   RipLine(x0,y0,x1,y1 : word);
  225.     procedure   RipRectangle(x0,y0,x1,y1 : word);
  226.     procedure   RipBar(x0,y0,x1,y1 : word);
  227.     procedure   RipCircle(x0,y0,radius : word);
  228.     procedure   RipOval(x0,y0,stangle,endangle,xrad,yrad : word);
  229.     procedure   RipFilledOval(x0,y0,xrad,yrad : word);
  230.     procedure   RipArc(x0,y0,stangle,endangle,rad : word);
  231.     procedure   RipOvalArc(x0,y0,stangle,endangle,xrad,yrad : word);
  232.     procedure   RipPieSlice(x0,y0,stangle,endangle,rad : word);
  233.     procedure   RipOvalPieSlice(x0,y0,stangle,endangle,radx,rady : word);
  234.     procedure   RipBezier(x0,y0,x1,y1,x2,y2,x3,y3,count : word);
  235.     procedure   RipPolygon(numpoints : word; var polypoints);
  236.     procedure   RipFillPoly(numpoints : word; var polypoints);
  237.     procedure   RipPolyLine(NumPoints : word; var polypoints);
  238.     procedure   RipFill(x0,y0,border : word);
  239.     procedure   RipLineStyle(style,pattern,thick : word);
  240.     procedure   RipFillStyle(style,color : word);
  241.     procedure   RipFillPattern(pattern : fpt; color : word);
  242.     procedure   RipMouse(x0,y0,x1,y1 : word; click, clear : boolean; instr : string);
  243.     procedure   RipKillMouseFields;
  244.     procedure   RipBeginText(x0,y0,x1,y1 : word);
  245.     procedure   RipRegionText(Justify : boolean; instr : string);
  246.     procedure   RipEndText;
  247.     procedure   RipGetImage(x0,y0,x1,y1 : word);
  248.     procedure   RipPutImage(x0,y0,mode : word);
  249.     procedure   RipWriteIcon(fname : str12);
  250.     procedure   RipLoadIcon(x0,y0,mode : word; clipbrd : boolean; fname : str12);
  251.     procedure   RipButtonStyle(wid,hgt,orient,flags,bevsize,dfore,dback,bright,dark,
  252.                                surface,grp_no,flags2,uline_col,corner_col : word);
  253.     procedure   RipButton(x0,y0,x1,y1,hotkey : word; flags : byte; icon : str12; sLabel : string; Cmd : string);
  254.     procedure   RipDefine(flags : word; textvar : str12; width : byte; ques, default : string);
  255.     procedure   RipQuery(mode : byte; instr : string);
  256.     procedure   RipCopyRegion(x0,y0,x1,y1,destline : word);
  257.     procedure   RipReadScene(fname : str12);
  258.     procedure   RipFileQuery(mode : word; fname : str12);
  259.     procedure   RipEnterBlockMode(ul : boolean; proto,ftype : word; fname : str12);
  260.     procedure   RipNoMore;
  261.     procedure   SendStr(instr : string); virtual;
  262.     procedure   SendStrCR(instr : string); virtual;
  263.     procedure   StatLine;
  264.     destructor  Done; virtual;
  265.     Function    DisplayRIPfile(Path : string): boolean;
  266.     Procedure   ResetParser;
  267.     Procedure   ResetParser2(c:char);
  268.     Procedure   DumpBuffer;
  269.     Procedure   DumpBuffer2;
  270.     Procedure   ParseRipStr(s:string;sendchar:boolean);
  271.     Procedure   ParseRip(c : char; sendchar : boolean);
  272.     Procedure   DoTextStr(s:string);
  273.     Procedure   DoTextChar(c:char);
  274.     {$IFDEF MOUSE}
  275.     Procedure   MouseInit;
  276.     Procedure   MouseOn;
  277.     Procedure   MouseOff;
  278.     Procedure   GetPosition(var ButtonStatus,xPos,yPos:Integer);
  279.     Procedure   SetMousePos(x,y:Integer);
  280.     Procedure   IsButtonDown(Button:Integer; var Status,DnCount,xPos,yPos:Integer);
  281.     Procedure   IsButtonUp(Button:Integer; var Status,UpCount,xPos,yPos:Integer);
  282.     Procedure   CheckMouse;
  283.     Function    InRegion(x,y:word):byte;
  284.     Procedure   DoInvert(region:byte;InvertIt:boolean);
  285.     Procedure   AddRegion(x0,y0,x1,y1:word;invert,reset:boolean;thetext:str50);
  286.     Function    CharInBuffer: boolean;
  287.     Function    GetNextChar:char;
  288.     Procedure   AddString(st:string);
  289.     Procedure   KillRegions;
  290.     Procedure   KillBuffer;
  291.     {$ENDIF}
  292.     {$IFNDEF TP55}
  293.     private
  294.     {$ENDIF}
  295.     Procedure rTextWindow(x0,y0,x1,y1:byte; wrap:boolean; size:byte);
  296.     Procedure rViewPort(x0,y0,x1,y1:word);
  297.     Procedure rResetWindows;
  298.     Procedure rEraseWindow;
  299.     Procedure rEraseView;
  300.     Procedure rGotoXY(x0,y0:byte);
  301.     Procedure rHome;
  302.     Procedure rEraseEOL;
  303.     Procedure rColor(clr:byte);
  304.     Procedure rSetPalette(c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12,c13,c14,c15,c16:word);
  305.     Procedure rOnePalette(color,value:word);
  306.     Procedure rWriteMode(mode:byte);
  307.     Procedure rMove(x0,y0:word);
  308.     Procedure rText(instr:string);
  309.     Procedure rTextXY(x0,y0:word; instr:string);
  310.     Procedure rFontStyle(font,direct,size:byte);
  311.     Procedure rPixel(x0,y0:word);
  312.     Procedure rLine(x0,y0,x1,y1:word);
  313.     Procedure rRectangle(x0,y0,x1,y1:word);
  314.     Procedure rBar(x0,y0,x1,y1:word);
  315.     Procedure rCircle(x0,y0,radius:word);
  316.     Procedure rOval(x0,y0,stangle,endangle,xrad,yrad:word);
  317.     Procedure rFilledOval(x0,y0,xrad,yrad:word);
  318.     Procedure rArc(x0,y0,stangle,endangle,rad:word);
  319.     Procedure rPieSlice(x0,y0,stangle,endangle,rad:word);
  320.     Procedure rOvalPieSlice(x0,y0,stangle,endangle,radx,rady:word);
  321.     Procedure rBezier(x0,y0,x1,y1,x2,y2,x3,y3,count:word);
  322.     Procedure rPolygon(numpoints:word; var PolyPoints; Complete:boolean);
  323.     Procedure rFillPoly(numpoints:word; var polypoints);
  324.     Procedure rFill(x0,y0,border:word);
  325.     Procedure rLineStyle(style,pattern,thick:word);
  326.     Procedure rFillStyle(style,color:word);
  327.     Procedure rFillPattern(pattern:fpt; color:word);
  328.     Procedure rMouse(x0,y0,x1,y1:word; inv,reset:boolean; instr:string);
  329.     Procedure rKillMouse;
  330.     Procedure rGetImage(x0,y0,x1,y1:word);
  331.     Procedure rPutImage(x0,y0,mode:word);
  332.     Procedure rWriteIcon(fname:str12);
  333.     Procedure rLoadIcon(x0,y0,mode:word; clipbrd:boolean; fname:str12);
  334.     Procedure rButtonStyle(wid,hgt,orient,flags,bevsize,dfore,dback,bright,dark,
  335.                            surface,grp_no,flags2,uline_col,corner_col:word);
  336.     Procedure rButton(tx0,ty0,tx1,ty1,hotkey:word; flags:byte; icon:str12; sLabel,Cmd:string);
  337.  
  338.     Function  MegaBuf(tpos,a,b:byte):word;
  339.     Function  UnEscapeString(bStart,bEnd:word):string;
  340.     Function  DoRipChar(c : char): boolean;
  341.  
  342.     procedure ProcessChar(C : Char; var pCommand : CommandRecord);
  343.     procedure PutQueue(C : Char);
  344.     procedure InitParser;
  345.     procedure BuildParam(C : Char);
  346.     procedure ConvertParams(C : Char);
  347.     procedure MakeCommand(C : Char; var pCommand : CommandRecord);
  348.  
  349.     Procedure DispChar(c:char);
  350.   end;
  351.  
  352. var
  353.   RIPScriptFont        : word;
  354.   RIPSimplexFont       : word;
  355.   RIPTriplexScriptFont : word;
  356.   RIPComplexFont       : word;
  357.   RIPEuropeanFont      : word;
  358.   RIPBoldFont          : word;
  359.  
  360.   UnregDelay     : Boolean;
  361.  
  362. Implementation
  363.  
  364.   {$IFDEF INTDRIV}
  365. uses
  366.   RipLinkMoreDrivers, RipLinkEvenMoreDrivers, RipLinkDriver;
  367.   {$ENDIF}
  368.  
  369. Var
  370.   Registered     : Boolean;
  371.   Regs           : registers;
  372.  
  373.  
  374. Constructor Root.Init;
  375. begin
  376. end;
  377.  
  378. Destructor Root.Done;
  379. begin
  380. end;
  381.  
  382. {$I RIPLINK.PA1}
  383.  
  384. Constructor RipObj.Init(userip : boolean;fontname : string);
  385. var
  386.   GrDriver      : integer;
  387.   GrMode        : Integer;
  388.   success       : boolean;
  389.   tres          : integer;
  390.   rnd1          : word;
  391.   rnd2          : word;
  392.   c             : byte;
  393. begin
  394.   if not Root.Init then
  395.     fail;
  396.  
  397.   LocalRip := userip;
  398.   success := true;
  399.   TMaxX0 := Lo(WindMin)+1;
  400.   TMaxY0 := Hi(WindMin)+1;
  401.   TMaxX1 := Lo(WindMax)+1;
  402.   TMaxY1 := Hi(WindMax)-1;
  403.  
  404.   level := 0;
  405.   sublevel := 0;
  406.   command := #0;
  407.   firstcmd := true;
  408.   nextcommand := false;
  409.   commanddone := false;
  410.   didrip      := false;
  411.   pstat := none;
  412.   cstat := cnone;
  413.   lastc := #0;
  414.   fillchar(rbuffer,1024,#0);
  415.   bufcount := 0;
  416.  
  417.   DefColor := 0;
  418.   if LocalRip then
  419.   begin
  420.     RIPScriptFont        := InstallUserFont('SCRI');
  421.     if GraphResult <> grOk then
  422.       success := false;
  423.     RIPSimplexFont       := InstallUserFont('SIMP');
  424.     if GraphResult <> grOk then
  425.       success := false;
  426.     RIPTriplexScriptFont := InstallUserFont('TSCR');
  427.     if GraphResult <> grOk then
  428.       success := false;
  429.     RIPComplexFont       := InstallUserFont('LCOM');
  430.     if GraphResult <> grOk then
  431.       success := false;
  432.     RIPEuropeanFont      := InstallUserFont('EURO');
  433.     if GraphResult <> grOk then
  434.       success := false;
  435.     {$IFNDEF TP6}
  436.     RIPBoldFont          := InstallUserFont('BOLD');
  437.     if GraphResult <> grOk then
  438.       success := false;
  439.     {$ENDIF}
  440.  
  441.     {$IFDEF INTDRIV}
  442.     if RegisterBGIDriver(@EGAVGADriver) < 0 then
  443.     begin
  444.       Root.Done;
  445.       Fail;
  446.     end;
  447.  
  448.     if RegisterBGIFont(@GothicFont) < 0 then
  449.       success := false;
  450.     if RegisterBGIFont(@LittFont) < 0 then
  451.       success := false;
  452.     if RegisterBGIFont(@SansSerifFont) < 0 then
  453.       success := false;
  454.     if RegisterBGIFont(@TripFont) < 0 then
  455.       success := false;
  456.  
  457.     {$IFNDEF TP6}
  458.     if RegisterBGIFont(@BoldFont) < 0 then
  459.       success := false;
  460.     {$ENDIF}
  461.     if RegisterBGIFont(@EuroFont) < 0 then
  462.       success := false;
  463.     if RegisterBGIFont(@LComFont) < 0 then
  464.       success := false;
  465.     if RegisterBGIFont(@ScriptFont) < 0 then
  466.       success := false;
  467.     if RegisterBGIFont(@SimplexFont) < 0 then
  468.       success := false;
  469.     if RegisterBGIFont(@TriplexScriptFont) < 0 then
  470.       success := false;
  471.     {$ENDIF} {intdriv}
  472.  
  473.     if fontname = '' then
  474.       fontname := 'RIPLINK';
  475.  
  476.     {$IFDEF FONTFILE}
  477.     assign(charfile,fontname+'.CHR');
  478.     {$I-}
  479.     reset(charfile,1);
  480.     {$I+}
  481.     if ioresult <> 0 then
  482.       success := false;
  483.     GetMem(driverptr,5527);
  484.     blockread(charfile,driverptr^,5527);
  485.     if RegisterBGIdriver(driverptr) < 0 then
  486.       success := false;
  487.     FontPtr       := nil;
  488.     FontSize      := 0;
  489.     {$ENDIF} {fontfile}
  490.  
  491.     if not success then
  492.     begin
  493.       Root.Done;
  494.       Fail;
  495.     end;
  496.  
  497.     Grdriver := 0;
  498.     GrMode   := 0;
  499.     DetectGraph(GrDriver, GrMode);
  500.     case GrDriver of
  501.       Graph.EGA   : GrMode:=Graph.EGAHi;
  502.       Graph.EGA64 : GrMode:=Graph.EGA64Hi;
  503.       Graph.VGA   : If GrMode<>Graph.VGAHi then
  504.                       GrMode:=Graph.VGAMed;
  505.       else
  506.         success := false;
  507.     end;
  508.  
  509. {   GrDriver := Graph.EGA64;
  510.     GrMode   := Graph.EGA64Hi; }
  511. {   GrDriver := Graph.VGA;
  512.     GrMode   := Graph.VGAHi; }
  513.  
  514.     InitGraph(GrDriver, GrMode,'');
  515.     tres := graphresult;
  516.     if tres <> grOk then
  517.       success := false;
  518.     SetTextJustify(LeftText,TopText);
  519.     {ansi parser}
  520.     if (MaxAvail < iQueueSize) or (iQueueSize = 0) then
  521.       Fail;
  522.     GetMem(Queue,iQueueSize);
  523.     QueueSize := iQueueSize;
  524.     QueueIndex := 0;
  525.     aTextAttr := TextAttr;
  526.     Intense := False;
  527.     Inverse := False;
  528.     Blink := False;
  529.     Invis := False;
  530.     InitParser;
  531.     {text window}
  532.     textx0 := 0;  texty0 := 0;
  533.     textx1 := 79; texty1 := 42;
  534.     textsize := 0;
  535.     textwrap := true;
  536.     textclr := 15;
  537.     textactive := true;
  538.     cursorx := 0; cursory := 0;
  539.     cursoron := false;
  540.     fillchar(virtualwindow,7826,#0);
  541.     filemode := $20;
  542.     assign(textfontfile,fontname+'.FNT');
  543.     {$I-}
  544.     reset(textfontfile);
  545.     {$I+}
  546.     if IOresult <> 0 then
  547.       success := false;
  548.   end;
  549.   if not success then
  550.   begin
  551.     Root.Done;
  552.     Fail;
  553.   end;
  554.   ClipB := nil;
  555.   ClipSize := 0;
  556.   {$IFDEF MOUSE}
  557.   mouseexist := false;
  558.   if LocalRip then
  559.       MouseInit;
  560.   {$ENDIF}
  561.   CurFont   := 0;
  562.   CurSize   := 1;
  563.   Metric    := MetricArray[CurFont,CurSize];
  564.   IconDir := '.\';
  565.   StatText := 'RipLink v1.21';
  566.   {$IFDEF DEBUGIT}
  567.   assign(log,'riplink.log');
  568.   if exists('riplink.log') then
  569.     append(log)
  570.   else
  571.     rewrite(log);
  572.   {$ENDIF}
  573. end;
  574.  
  575. Destructor RipObj.Done;
  576. begin
  577.   {$IFDEF DEBUGIT}
  578.   close(log);
  579.   {$ENDIF}
  580.   if LocalRip then
  581.   begin
  582.     close(textfontfile);
  583.     FreeMem(Queue,QueueSize);
  584.     {$IFDEF MOUSE}
  585.     regs.ax := $0000;
  586.     intr($33,regs);
  587.     mouseexist := (regs.ax = $ffff);
  588.     ismouseon := false;
  589.     {$ENDIF}
  590.     if ClipB <> nil then
  591.     begin
  592.       FreeMem(ClipB,ClipSize);
  593.       ClipB := nil;
  594.       ClipSize := 0;
  595.     end;
  596.     CloseGraph;
  597.     {$IFDEF FONTFILE}
  598.     FreeMem(driverptr,5527);
  599.     if fontptr <> nil then
  600.       freemem(fontptr,fontsize);
  601.     close(charfile);
  602.     {$ENDIF}
  603.   end;
  604.   Root.Done;
  605. end;
  606.  
  607. Procedure RipObj.RipTextWindow(x0, y0, x1, y1: byte; wrap : boolean; size : byte);
  608. var
  609.   wtemp : char;
  610. begin
  611.   rTextWindow(x0,y0,x1,y1,wrap,size);
  612.   if wrap then
  613.     wtemp := '1'
  614.   else
  615.     wtemp := '0';
  616.   sendstrcr('!|w'+WordToMega(x0)+WordToMega(y0)+WordToMega(x1)+WordToMega(y1)+wtemp+inttostr(size));
  617. end;
  618.  
  619. Procedure RipObj.RipViewPort(x0,y0,x1,y1 : word);
  620. begin
  621.   rViewPort(x0,y0,x1,y1);
  622.   sendstrcr('!|v'+WordToMega(x0)+WordToMega(y0)+WordToMega(x1)+WordToMega(y1));
  623. end;
  624.  
  625. Procedure RipObj.RipResetWindows;
  626. begin
  627.   rResetWindows;
  628.   sendstrcr('!|*');
  629. end;
  630.  
  631. Procedure RipObj.RipEraseWindow;
  632. begin
  633.   rEraseWindow;
  634.   sendstrcr('!|e');
  635. end;
  636.  
  637. Procedure RipObj.RipEraseView;
  638. begin
  639.   rEraseView;
  640.   sendstrcr('!|E');
  641. end;
  642.  
  643. Procedure RipObj.RipGotoXY(x0,y0 : byte);
  644. begin
  645.   rGotoXY(x0,y0);
  646.   sendstrcr('!|g'+WordToMega(x0)+WordToMega(y0));
  647. end;
  648.  
  649. Procedure RipObj.RipHome;
  650. begin
  651.   rHome;
  652.   sendstrcr('!|H');
  653. end;
  654.  
  655. Procedure RipObj.RipEraseEOL;
  656. begin
  657.   rEraseEOL;
  658.   sendstrcr('!|>');
  659. end;
  660.  
  661. Procedure RipObj.RipColor(clr : byte);
  662. begin
  663.   rColor(clr);
  664.   sendstrcr('!|c'+wordtomega(clr));
  665. end;
  666.  
  667. Procedure RipObj.RipSetPalette(c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12,c13,c14,c15,c16 : word);
  668. begin
  669.   rSetPalette(c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12,c13,c14,c15,c16);
  670.   sendstrcr('!|Q'+wordtomega(c1)+wordtomega(c2)+wordtomega(c3)+wordtomega(c4)+wordtomega(c5)+wordtomega(c6)+
  671.                 wordtomega(c7)+wordtomega(c8)+wordtomega(c9)+wordtomega(c10)+wordtomega(c11)+wordtomega(c12)+
  672.                 wordtomega(c13)+wordtomega(c14)+wordtomega(c15)+wordtomega(c16));
  673. end;
  674.  
  675. Procedure RipObj.RipOnePalette(color,value : word);
  676. begin
  677.   rOnePalette(color,value);
  678.   sendstrcr('!|a'+wordtomega(color)+wordtomega(value));
  679. end;
  680.  
  681. Procedure RipObj.RipWriteMode(Mode : Byte);
  682. begin
  683.   rWriteMode(mode);
  684.   sendstrcr('!|W'+wordtomega(mode));
  685. end;
  686.  
  687. Procedure RipObj.RipMove(x0,y0 : word);
  688. begin
  689.   rMove(x0,y0);
  690.   sendstrcr('!|m'+wordtomega(x0)+wordtomega(y0));
  691. end;
  692.  
  693. Procedure RipObj.RipText(instr : string);
  694. begin
  695.   rText(instr);
  696.   sendstrcr('!|T'+escapestring(instr));
  697. end;
  698.  
  699. Procedure RipObj.RipTextXY(x0,y0 : word; instr : string);
  700. begin
  701.   rTextXY(x0,y0,instr);
  702.   sendstrcr('!|@'+wordtomega(x0)+wordtomega(y0)+escapestring(instr));
  703. end;
  704.  
  705. Procedure RipObj.RipFontStyle(font,direct,size : byte);
  706. begin
  707.   rFontStyle(font,direct,size);
  708.   sendstrcr('!|Y'+wordtomega(font)+wordtomega(direct)+wordtomega(size)+'00');
  709. end;
  710.  
  711. Procedure RipObj.RipPixel(x0,y0 : word);
  712. begin
  713.   rPixel(x0,y0);
  714.   sendstrcr('!|X'+wordtomega(x0)+wordtomega(y0));
  715. end;
  716.  
  717. Procedure RipObj.RipLine(x0,y0,x1,y1 : word);
  718. begin
  719.   rLine(x0,y0,x1,y1);
  720.   sendstrcr('!|L'+wordtomega(x0)+wordtomega(y0)+wordtomega(x1)+wordtomega(y1));
  721. end;
  722.  
  723. Procedure RipObj.RipRectangle(x0,y0,x1,y1 : word);
  724. begin
  725.   rRectangle(x0,y0,x1,y1);
  726.   sendstrcr('!|R'+wordtomega(x0)+wordtomega(y0)+wordtomega(x1)+wordtomega(y1));
  727. end;
  728.  
  729. Procedure RipObj.RipBar(x0,y0,x1,y1 : word);
  730. begin
  731.   rBar(x0,y0,x1,y1);
  732.   sendstrcr('!|B'+wordtomega(x0)+wordtomega(y0)+wordtomega(x1)+wordtomega(y1));
  733. end;
  734.  
  735. Procedure RipObj.RipCircle(x0,y0,radius : word);
  736. begin
  737.   rCircle(x0,y0,radius);
  738.   sendstrcr('!|C'+wordtomega(x0)+wordtomega(y0)+wordtomega(radius));
  739. end;
  740.  
  741. Procedure RipObj.RipOval(x0,y0,StAngle,EndAngle,xrad,yrad : word);
  742. begin
  743.   rOval(x0,y0,stangle,endangle,xrad,yrad);
  744.   sendstrcr('!|O'+wordtomega(x0)+wordtomega(y0)+wordtomega(stangle)+wordtomega(endangle)+wordtomega(xrad)+wordtomega(yrad));
  745. end;
  746.  
  747. Procedure RipObj.RipFilledOval(x0,y0,xrad,yrad : word);
  748. begin
  749.   rFilledOval(x0,y0,xrad,yrad);
  750.   sendstrcr('!|o'+wordtomega(x0)+wordtomega(y0)+wordtomega(xrad)+wordtomega(yrad));
  751. end;
  752.  
  753. Procedure RipObj.RipArc(x0,y0,StAngle,EndAngle,Rad : word);
  754. begin
  755.   rArc(x0,y0,stangle,endangle,rad);
  756.   sendstrcr('!|A'+wordtomega(x0)+wordtomega(y0)+wordtomega(stangle)+wordtomega(endangle)+wordtomega(rad));
  757. end;
  758.  
  759. Procedure RipObj.RipOvalArc(x0,y0,StAngle,EndAngle,xrad,yrad : word);
  760. begin
  761.   rOval(x0,y0,stangle,endangle,xrad,yrad);
  762.   sendstrcr('!|V'+wordtomega(x0)+wordtomega(y0)+wordtomega(stangle)+wordtomega(endangle)+wordtomega(xrad)+wordtomega(yrad));
  763. end;
  764.  
  765. Procedure RipObj.RipPieSlice(x0,y0,StAngle,EndAngle,Rad : word);
  766. begin
  767.   rPieSlice(x0,y0,stangle,endangle,rad);
  768.   sendstrcr('!|I'+wordtomega(x0)+wordtomega(y0)+wordtomega(stangle)+wordtomega(endangle)+wordtomega(rad));
  769. end;
  770.  
  771. Procedure RipObj.RipOvalPieSlice(x0,y0,StAngle,EndAngle,radx,rady : word);
  772. begin
  773.   rOvalPieSlice(x0,y0,stangle,endangle,radx,rady);
  774.   sendstrcr('!|i'+wordtomega(x0)+wordtomega(y0)+wordtomega(stangle)+wordtomega(endangle)+wordtomega(radx)+wordtomega(rady));
  775. end;
  776.  
  777. Procedure RipObj.RipBezier(x0,y0,x1,y1,x2,y2,x3,y3,count : word);
  778. begin
  779.   rBezier(x0,y0,x1,y1,x2,y2,x3,y3,count);
  780.   sendstrcr('!|Z'+wordtomega(x0)+wordtomega(y0)+wordtomega(x1)+wordtomega(y1)+
  781.                 wordtomega(x2)+wordtomega(y2)+wordtomega(x3)+wordtomega(y3));
  782. end;
  783.  
  784. Procedure RipObj.RipPolygon(NumPoints : word; var PolyPoints);
  785. type
  786.   PointRec = record
  787.     X : word;
  788.     Y : word;
  789.   end;
  790.  
  791.   TempType = Array[1..512] of PointRec;
  792. var
  793.   TempVar : TempType;
  794.   TempStr : string;
  795.   ctr     : word;
  796. begin
  797.   rPolygon(numpoints,polypoints,true);
  798.  
  799.   TempVar := TempType(PolyPoints);
  800.   tempstr := '';
  801.   for ctr := 1 to numpoints do
  802.     tempstr := tempstr + wordtomega(TempVar[ctr].X) + wordtomega(TempVar[ctr].Y);
  803.   sendstrcr('!|P'+wordtomega(numpoints)+tempstr);
  804. end;
  805.  
  806. Procedure RipObj.RipFillPoly(NumPoints : word; var polypoints);
  807. type
  808.   PointRec = record
  809.     X : word;
  810.     Y : word;
  811.   end;
  812.  
  813.   TempType = Array[1..512] of PointRec;
  814. var
  815.   TempVar : TempType;
  816.   TempStr : string;
  817.   ctr     : word;
  818. begin
  819.   rFillPoly(numpoints,polypoints);
  820.  
  821.   TempVar := TempType(PolyPoints);
  822.   tempstr := '';
  823.   for ctr := 1 to numpoints do
  824.     tempstr := tempstr + wordtomega(TempVar[ctr].X) + wordtomega(TempVar[ctr].Y);
  825.   sendstrcr('!|p'+wordtomega(numpoints)+tempstr);
  826. end;
  827.  
  828. Procedure RipObj.RipPolyLine(NumPoints : word; var polypoints);
  829. type
  830.   PointRec = record
  831.     X : word;
  832.     Y : word;
  833.   end;
  834.  
  835.   TempType = Array[1..512] of PointRec;
  836. var
  837.   TempVar : TempType;
  838.   TempStr : string;
  839.   ctr     : word;
  840. begin
  841.   rPolygon(numpoints,polypoints,false);
  842.  
  843.   TempVar := TempType(PolyPoints);
  844.   tempstr := '';
  845.   for ctr := 1 to numpoints do
  846.     tempstr := tempstr + wordtomega(TempVar[ctr].X) + wordtomega(TempVar[ctr].Y);
  847.   sendstrcr('!|l'+wordtomega(numpoints)+tempstr);
  848. end;
  849.  
  850. Procedure RipObj.RipFill(x0,y0,border : word);
  851. begin
  852.   rFill(x0,y0,border);
  853.   sendstrcr('!|F'+wordtomega(x0)+wordtomega(y0)+wordtomega(border));
  854. end;
  855.  
  856. Procedure RipObj.RipLineStyle(style, pattern, thick : word);
  857. begin
  858.   rLineStyle(style,pattern,thick);
  859.   sendstrcr('!|='+wordtomega(style)+wordtomega4(pattern)+wordtomega(thick));
  860. end;
  861.  
  862. Procedure RipObj.RipFillStyle(style, color : word);
  863. begin
  864.   rFillStyle(style,color);
  865.   sendstrcr('!|S'+wordtomega(style)+wordtomega(color));
  866. end;
  867.  
  868. Procedure RipObj.RipFillPattern(Pattern : fpt; color : word);
  869. begin
  870.   rFillPattern(pattern,color);
  871.   sendstrcr('!|s'+wordtomega(pattern[1])+wordtomega(pattern[2])+wordtomega(pattern[3])+wordtomega(pattern[4])+
  872.                 wordtomega(pattern[5])+wordtomega(pattern[6])+wordtomega(pattern[7])+wordtomega(pattern[8])+wordtomega(color));
  873. end;
  874.  
  875. Procedure RipObj.RipMouse(x0,y0,x1,y1 : word; click, clear : boolean; instr : string);
  876. var
  877.   ch1, ch2 : char;
  878. begin
  879.   if click then
  880.     ch1 := '1'
  881.   else
  882.     ch1 := '0';
  883.   if clear then
  884.     ch2 := '1'
  885.   else
  886.     ch2 := '0';
  887.   rMouse(x0,y0,x1,y1,click,clear,instr);
  888.   sendstrcr('!|1M00'+wordtomega(x0)+wordtomega(y0)+wordtomega(x1)+wordtomega(y1)+ch1+ch2+'00000'+escapestring(instr));
  889. end;
  890.  
  891. Procedure RipObj.RipKillMouseFields;
  892. begin
  893.   rKillMouse;
  894.   sendstrcr('!|1K');
  895. end;
  896.  
  897. Procedure RipObj.RipBeginText(x0,y0,x1,y1 : word);
  898. begin
  899.   sendstrcr('!|1T'+wordtomega(x0)+wordtomega(y0)+wordtomega(x1)+wordtomega(y1));
  900. end;
  901.  
  902. Procedure RipObj.RipRegionText(justify : boolean; instr : string);
  903. var
  904.   tch   : char;
  905. begin
  906.   if justify then
  907.     tch := '1'
  908.   else
  909.     tch := '0';
  910.   sendstrcr('!|1t'+tch+escapestring(instr));
  911. end;
  912.  
  913. Procedure RipObj.RipEndText;
  914. begin
  915.   sendstrcr('!|1E');
  916. end;
  917.  
  918. Procedure RipObj.RipGetImage(x0,y0,x1,y1 : word);
  919. begin
  920.   rGetImage(x0,y0,x1,y1);
  921.   sendstrcr('!|1C'+wordtomega(x0)+wordtomega(y0)+wordtomega(x1)+wordtomega(y1)+'0');
  922. end;
  923.  
  924. Procedure RipObj.RipPutImage(x0,y0,mode : word);
  925. begin
  926.   rPutImage(x0,y0,mode);
  927.   sendstrcr('!|1P'+wordtomega(x0)+wordtomega(y0)+wordtomega(mode)+'0');
  928. end;
  929.  
  930. Procedure RipObj.RipWriteIcon(fname : str12);
  931. begin
  932.   rWriteIcon(fname);
  933.   sendstrcr('!|1W0'+escapestring(fname));
  934. end;
  935.  
  936. Procedure RipObj.RipLoadIcon(x0,y0,mode : word; clipbrd : boolean; fname : str12);
  937. var
  938.   tch           : char;
  939. begin
  940.   rLoadIcon(x0,y0,mode,clipbrd,fname);
  941.   if clipbrd then
  942.     tch := '1'
  943.   else
  944.     tch := '0';
  945.   sendstrcr('!|1I'+wordtomega(x0)+wordtomega(y0)+wordtomega(mode)+tch+'10'+escapestring(fname));
  946. end;
  947.  
  948. Procedure RipObj.RipButtonStyle(wid,hgt,orient,flags,bevsize,dfore,dback,bright,dark,
  949.                                 surface,grp_no,flags2,uline_col,corner_col : word);
  950. begin
  951.   rButtonStyle(wid,hgt,orient,flags,bevsize,dfore,dback,bright,dark,surface,grp_no,flags2,uline_col,corner_col);
  952.   sendstrcr('!|1B'+wordtomega(wid)+wordtomega(hgt)+wordtomega(orient)+wordtomega4(flags)+wordtomega(bevsize)+
  953.                  wordtomega(dfore)+wordtomega(dback)+wordtomega(bright)+wordtomega(dark)+wordtomega(surface)+
  954.                  wordtomega(grp_no)+wordtomega(flags2)+wordtomega(uline_col)+wordtomega(corner_col)+'000000');
  955. end;
  956.  
  957. Procedure RipObj.RipButton(x0,y0,x1,y1,hotkey : word; flags : byte; icon : str12; sLabel : string; Cmd : string);
  958. var
  959.   flgch : char;
  960. begin
  961.   rButton(x0,y0,x1,y1,hotkey,flags,icon,slabel,cmd);
  962.   case flags of
  963.     0 : flgch := '0';
  964.     1 : flgch := '1';
  965.     2 : flgch := '2';
  966.     else
  967.       flgch := '0';
  968.   end;
  969.   sendstrcr('!|1U'+wordtomega(x0)+wordtomega(y0)+wordtomega(x1)+wordtomega(y1)+
  970.                  wordtomega(hotkey)+flgch+'0'+escapestring(icon)+
  971.                  '<>'+escapestring(sLabel)+'<>'+escapestring(cmd));
  972. end;
  973.  
  974. Procedure RipObj.RipDefine(flags : word; textvar : str12; width : byte; ques, default : string);
  975. begin
  976.   sendstrcr('!|1D0'+wordtomega(flags)+'00'+escapestring(textvar)+','+inttostr(width)+
  977.                   ':?'+escapestring(ques)+'?'+escapestring(default));
  978. end;
  979.  
  980. Procedure RipObj.RipQuery(mode : byte; instr : string);
  981. var
  982.   mch   : char;
  983. begin
  984.   case mode of
  985.     0 : mch := '0';
  986.     1 : mch := '1';
  987.     2 : mch := '2';
  988.     else
  989.       mch := '0';
  990.   end;
  991.   sendstrcr('!|1'+#27+mch+'000'+escapestring(instr));
  992. end;
  993.  
  994. Procedure RipObj.RipCopyRegion(x0,y0,x1,y1,destline : word);
  995. begin
  996.   sendstrcr('!|1G'+wordtomega(x0)+wordtomega(y0)+wordtomega(x1)+wordtomega(y1)+'00'+wordtomega(destline));
  997. end;
  998.  
  999. Procedure RipObj.RipReadScene(fname : str12);
  1000. begin
  1001.   sendstrcr('!|1R00000000'+escapestring(fname));
  1002. end;
  1003.  
  1004. Procedure RipObj.RipFileQuery(mode : word; fname : str12);
  1005. begin
  1006.   sendstrcr('!|1F'+wordtomega(mode)+'0000'+escapestring(fname));
  1007. end;
  1008.  
  1009. Procedure RipObj.RipEnterBlockMode(ul : boolean; proto,ftype : word; fname : str12);
  1010. var
  1011.   bstr : string;
  1012.   wtemp,bch: char;
  1013. begin
  1014.   if ul then
  1015.     wtemp := '1'
  1016.   else
  1017.     wtemp := '0';
  1018.   bstr := wordtomega(proto);
  1019.   bch  := bstr[2];
  1020.   sendstrcr('!|0'+#27+wtemp+bch+wordtomega(ftype)+'0000'+escapestring(fname)+'<>');
  1021. end;
  1022.  
  1023. Procedure RipObj.RipNoMore;
  1024. begin
  1025.   sendstrcr('!|#|#|#');
  1026. end;
  1027.  
  1028. Procedure RipObj.SendStr(instr : string);
  1029. begin
  1030.   runerror(211);
  1031. end;
  1032.  
  1033. Procedure RipObj.SendStrCR(instr : string);
  1034. begin
  1035.   SendStr(instr+#13#10);
  1036. end;
  1037.  
  1038. Procedure RipObj.StatLine;
  1039. var
  1040.   vpt   : ViewPortType;
  1041.   tst   : TextSettingsType;
  1042.   lst   : LineSettingsType;
  1043.   col   : word; {color}
  1044. begin
  1045.   if LocalRip then
  1046.   begin
  1047.     GetViewSettings(vpt);
  1048.     GetTextSettings(tst);
  1049.     GetLineSettings(lst);
  1050.     Col := GetColor;
  1051.     SetColor(0);
  1052.  
  1053.     SetViewPort(0,GetMaxY-12,GetMaxX,GetMaxY,true);
  1054.     SetTextStyle(defaultfont,horizdir,1);
  1055.     SetLineStyle(SolidLn,0,NormWidth);
  1056.     SetTextJustify(LeftText,TopText);
  1057.     ClearViewPort;
  1058.     SetColor(9);
  1059.     Rectangle(0,0,GetMaxX,11);
  1060.     SetColor(11);
  1061.     OutTextXY(3,3,StatText);
  1062.     SetColor(col);
  1063.     with vpt do
  1064.       SetViewPort(x1,y1,x2,y2,clip);
  1065.     with tst do
  1066.     begin
  1067.       SetTextStyle(font,direction,charsize);
  1068.       SetTextJustify(Horiz,Vert);
  1069.     end;
  1070.     with lst do
  1071.       SetLineStyle(LineStyle,Pattern,Thickness);
  1072.   end;
  1073. end;
  1074.  
  1075. Function RipObj.DisplayRIPfile(Path : string): boolean;
  1076. var
  1077.   ctr   : word;
  1078.   FName         : String;
  1079.   F             : file;
  1080.   FBuf          : Array [0..1023] of Char;
  1081.   BufRead       : Word;
  1082.   BufCnt        : Word;
  1083.   sBuf          : string;
  1084. begin
  1085.   displayripfile := false;
  1086.   sbuf := '';
  1087.   {if exists(Path) then}
  1088.     FName := Path
  1089.   {else
  1090.     Exit};
  1091.   filemode := $20;
  1092.   Assign(F,FName);
  1093.   {$I-}
  1094.   Reset(F,1);
  1095.   {$I+}
  1096.   if ioresult <> 0 then
  1097.   begin
  1098.     exit;
  1099.   end;
  1100.   displayripfile := true;
  1101.   While not EOF(F) do
  1102.   begin
  1103.     fillchar(FBuf,1024,#0);
  1104.     BlockRead(F,FBuf,1024,BufRead);
  1105.     For BufCnt := 0 to BufRead-1 do
  1106.     begin
  1107.       ParseRip(fbuf[bufcnt],false);
  1108.       if FBuf[BufCnt] <> #0 then
  1109.         sBuf := sBuf + FBuf[BufCnt];
  1110.       if length(sbuf) > 10 then
  1111.       begin
  1112.         sendstr(sbuf);
  1113.         sbuf := '';
  1114.       end;
  1115.     end;
  1116.   end;
  1117.   sendstr(sbuf);
  1118.   Close(F);
  1119. end;
  1120.  
  1121. Procedure RipObj.ResetParser;
  1122. begin
  1123.   fillchar(rbuffer,1024,#0);
  1124.   bufcount := 0;
  1125.   level := 0;
  1126.   sublevel := 0;
  1127.   command := #0;
  1128.   {lastc := #0;}
  1129.   firstcmd := false;
  1130.   if nextcommand then
  1131.     pstat := got_pipe
  1132.   else
  1133.     pstat := none;
  1134.   lstat := lNone;
  1135.   nextcommand := false;
  1136.   commanddone := false;
  1137.   cstat := cnone;
  1138. end;
  1139.  
  1140. Procedure RipObj.ResetParser2(c:char);
  1141. begin
  1142.   ResetParser;
  1143.   inc(bufcount);
  1144.   rbuffer[bufcount] := c;
  1145.   if c = #13 then
  1146.   begin
  1147.     firstcmd := true;
  1148.     dec(bufcount);
  1149.   end;
  1150. end;
  1151.  
  1152. Procedure RipObj.DumpBuffer;
  1153. var
  1154.   ctr : word;
  1155. begin
  1156.   for ctr := 1 to bufcount do
  1157.     DoTextChar(rbuffer[ctr]);
  1158.   resetparser;
  1159. end;
  1160.  
  1161. Procedure RipObj.DumpBuffer2;
  1162. var
  1163.   stor:boolean;
  1164. begin
  1165.   stor := firstcmd;
  1166.   ResetParser;
  1167.   firstcmd := stor;
  1168. end;
  1169.  
  1170. Procedure RipObj.ParseRipStr(s:string;sendchar:boolean);
  1171. var
  1172.   ctr : byte;
  1173. begin
  1174.   for ctr := 1 to length(s) do
  1175.     ParseRip(s[ctr],sendchar);
  1176. end;
  1177.  
  1178. Procedure RipObj.ParseRip(c : char;sendchar : boolean);
  1179. var
  1180.   ctr : word;
  1181.   b : boolean;
  1182. begin
  1183.   if sendchar then
  1184.     sendstr(c);
  1185.   b := DoRipChar(c);
  1186. end;
  1187.  
  1188. Function RipObj.MegaBuf(tpos,a,b:byte):word;
  1189. begin
  1190.   megabuf := megatoword(rbuffer[tpos+a]+rbuffer[tpos+b]);
  1191. end;
  1192.  
  1193. Function RipObj.UnEscapeString(bStart,bEnd:word):string;
  1194. var
  1195.   s : string;
  1196.   ctr : byte;
  1197. begin
  1198.   s := '';
  1199.   ctr := bStart-1;
  1200.   while ctr < bEnd-1 do
  1201.   begin
  1202.     inc(ctr);
  1203.     if rbuffer[ctr] = '\' then
  1204.     begin
  1205.       inc(ctr);
  1206.       if rbuffer[ctr] in ['\','|','!'] then
  1207.         s := s + rbuffer[ctr]
  1208.       else
  1209.         while rbuffer[ctr+1] in [#13,#10] do
  1210.           inc(ctr);
  1211.     end
  1212.     else
  1213.       s := s + rbuffer[ctr];
  1214.   end;
  1215.   unescapestring := s;
  1216. end;
  1217.  
  1218. Function RipObj.DoRipChar(c : char): boolean;
  1219. type
  1220.   PointRec = record
  1221.     X : word;
  1222.     Y : word;
  1223.   end;
  1224.  
  1225.   TempType = Array[1..512] of PointRec;
  1226. var
  1227.   doexit : boolean;
  1228.   st5    : string[7];
  1229.   tPos   : byte;
  1230.   st2    : string[2];
  1231.   w1,w2,w3,w4,w5,w6,w7,w8,w9,w10,w11,w12,w13,w14,w15,w16         : word;
  1232.   b1,b2,b3,b4,b5                                                 : byte;
  1233.   o1,o2                                                          : boolean;
  1234.   s1,s2,s3,s4                                                    : string;
  1235.   sCtr                                                           : byte;
  1236.   TempPoly : TempType;
  1237.   TempFPT  : fpt;
  1238.  
  1239.   Function MegaB(ch:char) :Boolean;
  1240.   begin
  1241.     if ch = '1' then
  1242.       megab := true
  1243.     else
  1244.       megab := false;
  1245.   end;
  1246.  
  1247.   Procedure DoTheButton;
  1248.   var
  1249.     sctr        : byte;
  1250.   begin
  1251.     {$IFDEF DEBUGPAUSE}
  1252.     readkey;
  1253.     {$ENDIF}
  1254.     s1 := ''; s2 := ''; s3 := ''; s4 := '';
  1255.     s1 := unescapestring(tpos+13,bufcount);
  1256.     case pos('<>',s1) of
  1257.       0 : begin
  1258.             if s1 <> '' then
  1259.             begin
  1260.               s2 := s1;
  1261.               s1 := '';
  1262.             end;
  1263.           end;
  1264.       1 : delete(s1,1{index},2{count});
  1265.       else
  1266.       begin
  1267.         s2 := copy(s1,1,pos('<>',s1)-1);
  1268.         delete(s1,1,pos('<>',s1)+1);
  1269.       end;
  1270.     end;
  1271.     case pos('<>',s1) of
  1272.       0 : begin
  1273.             if s1 <> '' then
  1274.             begin
  1275.               s3 := s1;
  1276.               s1 := '';
  1277.             end;
  1278.           end;
  1279.       1 : delete(s1,1{index},2{count});
  1280.       else
  1281.       begin
  1282.         s3 := copy(s1,1,pos('<>',s1)-1);
  1283.         delete(s1,1,pos('<>',s1)+1);
  1284.       end;
  1285.     end;
  1286.     case pos('<>',s1) of
  1287.       0 : begin
  1288.             if s1 <> '' then
  1289.             begin
  1290.               s4 := s1;
  1291.               s1 := '';
  1292.             end;
  1293.           end;
  1294.       1 : delete(s1,1{index},2{count});
  1295.       else
  1296.       begin
  1297.         s4 := copy(s1,1,pos('<>',s1)-1);
  1298.         delete(s1,1,pos('<>',s1)+1);
  1299.       end;
  1300.     end;
  1301.  
  1302.     w1 := megabuf(tpos,1,2);
  1303.     w2 := megabuf(tpos,3,4);
  1304.     w3 := megabuf(tpos,5,6);
  1305.     w4 := megabuf(tpos,7,8);
  1306.     w5 := megabuf(tpos,9,10);
  1307.     b1 := megatoword('0'+rbuffer[tpos+11]);
  1308.     rButton(w1,w2,w3,w4,w5,b1,s2,s3,s4);
  1309.     {$IFDEF DEBUGIT}
  1310.     writeln(log,'Button: ',w1,',',w2,',',w3,',',w4,',',w5,',',b1,',',s2,',',s3,',',s4);
  1311.     {$ENDIF}
  1312.   end;
  1313.  
  1314.   Procedure DoTheButtonStyle;
  1315.   begin
  1316.     {$IFDEF DEBUGPAUSE}
  1317.     readkey;
  1318.     {$ENDIF}
  1319.     w1 := megabuf(tpos,1,2);
  1320.     w2 := megabuf(tpos,3,4);
  1321.     w3 := megabuf(tpos,5,6);
  1322.     w4 := word(mega4tolong(rbuffer[tpos+7]+rbuffer[tpos+8]+rbuffer[tpos+9]+rbuffer[tpos+10]));
  1323.     w5 := megabuf(tpos,11,12);
  1324.     w6 := megabuf(tpos,13,14);
  1325.     w7 := megabuf(tpos,15,16);
  1326.     w8 := megabuf(tpos,17,18);
  1327.     w9 := megabuf(tpos,19,20);
  1328.     w10 := megabuf(tpos,21,22);
  1329.     w11 := megabuf(tpos,23,24);
  1330.     w12 := megabuf(tpos,25,26);
  1331.     w13 := megabuf(tpos,27,28);
  1332.     w14 := megabuf(tpos,29,30);
  1333.     rButtonStyle(w1,w2,w3,w4,w5,w6,w7,w8,w9,w10,w11,w12,w13,w14);
  1334.     {$IFDEF DEBUGIT}
  1335.     write(log,'Button Style: ',w1,',',w2,',',w3,',',w4,',',w5,',',w6,',',w7,',',w8);
  1336.     writeln(log,',',w9,',',w10,',',w11,',',w12,',',w13,',',w14);
  1337.     {$ENDIF}
  1338.   end;
  1339.  
  1340.   Procedure DoSetPalette;
  1341.   begin
  1342.     {$IFDEF DEBUGPAUSE}
  1343.     readkey;
  1344.     {$ENDIF}
  1345.     w1  := megabuf(tpos,1 ,2 );
  1346.     w2  := megabuf(tpos,3 ,4 );
  1347.     w3  := megabuf(tpos,5 ,6 );
  1348.     w4  := megabuf(tpos,7 ,8 );
  1349.     w5  := megabuf(tpos,9 ,10);
  1350.     w6  := megabuf(tpos,11,12);
  1351.     w7  := megabuf(tpos,13,14);
  1352.     w8  := megabuf(tpos,15,16);
  1353.     w9  := megabuf(tpos,17,18);
  1354.     w10 := megabuf(tpos,19,20);
  1355.     w11 := megabuf(tpos,21,22);
  1356.     w12 := megabuf(tpos,23,24);
  1357.     w13 := megabuf(tpos,25,26);
  1358.     w14 := megabuf(tpos,27,28);
  1359.     w15 := megabuf(tpos,29,30);
  1360.     w16 := megabuf(tpos,31,32);
  1361.     rSetPalette(w1,w2,w3,w4,w5,w6,w7,w8,w9,w10,w11,w12,w13,w14,w15,w16);
  1362.     {$IFDEF DEBUGIT}
  1363.     write(log,'Set Palette: ',w1,',',w2,',',w3,',',w4,',',w5,',',w6,',',w7,',',w8);
  1364.     writeln(log,',',w9,',',w10,',',w11,',',w12,',',w13,',',w14,',',w15,',',w16);
  1365.     {$ENDIF}
  1366.   end;
  1367.  
  1368.   Procedure DoFillPattern;
  1369.   begin
  1370.     {$IFDEF DEBUGPAUSE}
  1371.     readkey;
  1372.     {$ENDIF}
  1373.     tempfpt[1] := megabuf(tpos,1,2);
  1374.     tempfpt[2] := megabuf(tpos,3,4);
  1375.     tempfpt[3] := megabuf(tpos,5,6);
  1376.     tempfpt[4] := megabuf(tpos,7,8);
  1377.     tempfpt[5] := megabuf(tpos,9,10);
  1378.     tempfpt[6] := megabuf(tpos,11,12);
  1379.     tempfpt[7] := megabuf(tpos,13,14);
  1380.     tempfpt[8] := megabuf(tpos,15,16);
  1381.     w1 := megabuf(tpos,17,18);
  1382.     rFillpattern(tempfpt,w1);
  1383.     {$IFDEF DEBUGIT}
  1384.     write(log,'Fill Pattern: ',tempfpt[1],',',tempfpt[2],',');
  1385.     write(log,tempfpt[3],',',tempfpt[4],',',tempfpt[5],',',tempfpt[6],',');
  1386.     writeln(log,tempfpt[7],',',tempfpt[8],',',w1);
  1387.     {$ENDIF}
  1388.   end;
  1389.  
  1390. begin
  1391.   doripchar := false;
  1392.  
  1393.   inc(bufcount);
  1394.   rbuffer[bufcount] := c;
  1395.  
  1396.   doexit := false;
  1397.  
  1398.   if c in [#13,#10,'!'] then
  1399.   begin
  1400.     if (c = #13) and (lstat <> lBackSlash) then
  1401.     begin
  1402.       firstcmd := true;
  1403.     end;
  1404.     if (not didrip) and (c = '!') and (lastc = #10) then
  1405.       firstcmd := true;
  1406.   end
  1407.   else
  1408.     firstcmd := false;
  1409.  
  1410.   lastc := c;
  1411.  
  1412.   case pstat of
  1413.     None          : begin
  1414.       if firstcmd then
  1415.       begin
  1416.         if c = '!' then
  1417.           pstat := got_excl
  1418.         else
  1419.         begin
  1420.           if not (c in [#13,#10]) then
  1421.             dumpbuffer
  1422.           else
  1423.             if didrip then
  1424.             begin
  1425.               dec(bufcount);
  1426.               if c = #10 then
  1427.                 didrip := false;
  1428.             end
  1429.             else
  1430.               dumpbuffer;
  1431.           exit;
  1432.         end;
  1433.       end
  1434.       else
  1435.         if c in [#1,#2] then
  1436.           pstat := got_excl
  1437.         else
  1438.           if c = '|' then
  1439.             pstat := got_pipe
  1440.           else
  1441.           begin
  1442.             dumpbuffer;
  1443.             exit;
  1444.           end;
  1445.     end;
  1446.     Got_Excl      : begin
  1447.       didrip := true;
  1448.       if c = '|' then
  1449.         pstat := got_pipe
  1450.       else
  1451.       begin
  1452.         dumpbuffer;
  1453.         exit;
  1454.       end;
  1455.     end;
  1456.     Got_Pipe      : begin
  1457.       didrip := true;
  1458.       case c of
  1459.         '1'..'9' : begin
  1460.                      level := strtoint(c);
  1461.                      pstat := got_level;
  1462.                    end;
  1463.         #27,'#','*','=','>','@','A'..'Z','a'..'z' :
  1464.                    begin
  1465.                      level := 0;
  1466.                      command := c;
  1467.                      pstat := got_command;
  1468.                    end;
  1469.         else
  1470.         begin
  1471.           dumpbuffer;
  1472.           exit;
  1473.         end;
  1474.       end;
  1475.     end;
  1476.     Got_Level     : begin
  1477.       case c of
  1478.         '1'..'9' : begin
  1479.                      sublevel := strtoint(c);
  1480.                      pstat := got_sublevel;
  1481.                    end;
  1482.         #27,'#','*','=','>','@','A'..'Z','a'..'z' :
  1483.                    begin
  1484.                      command := c;
  1485.                      pstat := got_command;
  1486.                    end;
  1487.         else
  1488.         begin
  1489.           dumpbuffer;
  1490.           exit;
  1491.         end;
  1492.       end;
  1493.     end;
  1494.     Got_SubLevel  : begin
  1495.       if c in [#27,'#','*','=','>','@','A'..'Z','a'..'z'] then
  1496.       begin
  1497.         command := c;
  1498.         pstat := got_command;
  1499.       end
  1500.       else
  1501.       begin
  1502.         dumpbuffer;
  1503.         exit;
  1504.       end;
  1505.     end;
  1506.     Got_Command   : begin
  1507.       if (c = '|') and not (lstat = lBackSlash) then
  1508.         nextcommand := true;
  1509.  
  1510.       case c of
  1511.         #13 : lstat := lCR;
  1512.         #10 : lstat := lLF;
  1513.         '|' : lstat := lPipe;
  1514.         '\' : lstat := lBackSlash;
  1515.         '!' : lstat := lExcl;
  1516.         else
  1517.           lstat := lChar;
  1518.       end;
  1519.  
  1520.       if firstcmd {and (cstat <> contline) and (cstat <> pending)} then
  1521.         doexit := true;
  1522. {     case cstat of
  1523.         pending  : begin
  1524.                      if c = #13 then
  1525.                        cstat := contline
  1526.                      else
  1527.                        cstat := escaped;
  1528.                    end;
  1529.         contline : cstat := cnone;
  1530.       end;}
  1531.       st5 := rbuffer[1]+rbuffer[2]+rbuffer[3]+rbuffer[4]+rbuffer[5]+rbuffer[6]+rbuffer[7];
  1532.       tpos := pos(command,st5);
  1533.       case level of
  1534.         0  : begin
  1535.           case command of
  1536.             'w' : begin {text window}
  1537.                     if bufcount = (tpos+10) then
  1538.                     begin
  1539.                       {$IFDEF DEBUGPAUSE}
  1540.                       readkey;
  1541.                       {$ENDIF}
  1542.                       b1 := megabuf(tpos,1,2);
  1543.                       b2 := megabuf(tpos,3,4);
  1544.                       b3 := megabuf(tpos,5,6);
  1545.                       b4 := megabuf(tpos,7,8);
  1546.                       b5 := megatoword('0'+rbuffer[tpos+10]);
  1547.                       o1 := megab(rbuffer[tpos+9]);
  1548.                       rTextWindow(b1,b2,b3,b4,o1,b5);
  1549.                       {$IFDEF DEBUGIT}
  1550.                       writeln(log,'Text Window: ',b1,',',b2,',',b3,',',b4,',',o1,',',b5);
  1551.                       {$ENDIF}
  1552.                       resetparser;
  1553.                       exit;
  1554.                     end;
  1555.                   end;
  1556.             'v' : begin {view port}
  1557.                     if bufcount = (tpos+ 8) then
  1558.                     begin
  1559.                       {$IFDEF DEBUGPAUSE}
  1560.                       readkey;
  1561.                       {$ENDIF}
  1562.                       w1 := megabuf(tpos,1,2);
  1563.                       w2 := megabuf(tpos,3,4);
  1564.                       w3 := megabuf(tpos,5,6);
  1565.                       w4 := megabuf(tpos,7,8);
  1566.                       rViewPort(w1,w2,w3,w4);
  1567.                       {$IFDEF DEBUGIT}
  1568.                       writeln(log,'View Port: ',w1,',',w2,',',w3,',',w4);
  1569.                       {$ENDIF}
  1570.                       resetparser;
  1571.                       exit;
  1572.                     end;
  1573.                   end;
  1574.             '*' : begin {reset windows}
  1575.                     {$IFDEF DEBUGPAUSE}
  1576.                     readkey;
  1577.                     {$ENDIF}
  1578.                     rResetWindows;
  1579.                     {$IFDEF DEBUGIT}
  1580.                     writeln(log,'Reset Windows');
  1581.                     {$ENDIF}
  1582.                     resetparser2(c);
  1583.                     exit;
  1584.                   end;
  1585.             'e' : begin {erase window}
  1586.                     {$IFDEF DEBUGPAUSE}
  1587.                     readkey;
  1588.                     {$ENDIF}
  1589.                     rEraseWindow;
  1590.                     {$IFDEF DEBUGIT}
  1591.                     writeln(log,'Erase Window');
  1592.                     {$ENDIF}
  1593.                     resetparser2(c);
  1594.                     exit;
  1595.                   end;
  1596.             'E' : begin {erase view}
  1597.                     {$IFDEF DEBUGPAUSE}
  1598.                     readkey;
  1599.                     {$ENDIF}
  1600.                     rEraseView;
  1601.                     {$IFDEF DEBUGIT}
  1602.                     writeln(log,'Erase View');
  1603.                     {$ENDIF}
  1604.                     resetparser2(c);
  1605.                     exit;
  1606.                   end;
  1607.             'g' : begin {gotoxy}
  1608.                     if bufcount = (tpos+ 4) then
  1609.                     begin
  1610.                       {$IFDEF DEBUGPAUSE}
  1611.                       readkey;
  1612.                       {$ENDIF}
  1613.                       b1 := megabuf(tpos,1,2);
  1614.                       b2 := megabuf(tpos,3,4);
  1615.                       rGotoXY(b1,b2);
  1616.                       {$IFDEF DEBUGIT}
  1617.                       writeln(log,'GotoXY: ',b1,',',b2);
  1618.                       {$ENDIF}
  1619.                       resetparser;
  1620.                       exit;
  1621.                     end;
  1622.                   end;
  1623.             'H' : begin {home}
  1624.                     {$IFDEF DEBUGPAUSE}
  1625.                     readkey;
  1626.                     {$ENDIF}
  1627.                     rHome;
  1628.                     {$IFDEF DEBUGIT}
  1629.                     writeln(log,'Home');
  1630.                     {$ENDIF}
  1631.                     resetparser2(c);
  1632.                     exit;
  1633.                   end;
  1634.             '>' : begin {erase eol}
  1635.                     {$IFDEF DEBUGPAUSE}
  1636.                     readkey;
  1637.                     {$ENDIF}
  1638.                     rEraseEOL;
  1639.                     {$IFDEF DEBUGIT}
  1640.                     writeln(log,'EraseEOL');
  1641.                     {$ENDIF}
  1642.                     resetparser2(c);
  1643.                     exit;
  1644.                   end;
  1645.             'c' : begin {color}
  1646.                     if bufcount = (tpos+ 2) then
  1647.                     begin
  1648.                       {$IFDEF DEBUGPAUSE}
  1649.                       readkey;
  1650.                       {$ENDIF}
  1651.                       b1 := megabuf(tpos,1,2);
  1652.                       rColor(b1);
  1653.                       {$IFDEF DEBUGIT}
  1654.                       writeln(log,'Color: ',b1);
  1655.                       {$ENDIF}
  1656.                       resetparser;
  1657.                       exit;
  1658.                     end;
  1659.                   end;
  1660.             'Q' : begin {set palette}
  1661.                     if bufcount = (tpos+ 32) then
  1662.                     begin
  1663.                       DoSetPalette;
  1664.                       resetparser;
  1665.                       exit;
  1666.                     end;
  1667.                   end;
  1668.             'a' : begin {one palette}
  1669.                     if bufcount = (tpos+ 4) then
  1670.                     begin
  1671.                       {$IFDEF DEBUGPAUSE}
  1672.                       readkey;
  1673.                       {$ENDIF}
  1674.                       w1 := megabuf(tpos,1,2);
  1675.                       w2 := megabuf(tpos,3,4);
  1676.                       rOnePalette(w1,w2);
  1677.                       {$IFDEF DEBUGIT}
  1678.                       writeln(log,'One Palette: ',w1,',',w2);
  1679.                       {$ENDIF}
  1680.                       resetparser;
  1681.                       exit;
  1682.                     end;
  1683.                   end;
  1684.             'W' : begin {write mode}
  1685.                     if bufcount = (tpos+ 2) then
  1686.                     begin
  1687.                       {$IFDEF DEBUGPAUSE}
  1688.                       readkey;
  1689.                       {$ENDIF}
  1690.                       b1  := megabuf(tpos,1,2);
  1691.                       rWriteMode(b1);
  1692.                       {$IFDEF DEBUGIT}
  1693.                       writeln(log,'Write Mode: ',b1);
  1694.                       {$ENDIF}
  1695.                       resetparser;
  1696.                       exit;
  1697.                     end;
  1698.                   end;
  1699.             'm' : begin {move}
  1700.                     if bufcount = (tpos+ 4) then
  1701.                     begin
  1702.                       {$IFDEF DEBUGPAUSE}
  1703.                       readkey;
  1704.                       {$ENDIF}
  1705.                       w1 := megabuf(tpos,1,2);
  1706.                       w2 := megabuf(tpos,3,4);
  1707.                       rMove(w1,w2);
  1708.                       {$IFDEF DEBUGIT}
  1709.                       writeln(log,'Move: ',w1,',',w2);
  1710.                       {$ENDIF}
  1711.                       resetparser;
  1712.                       exit;
  1713.                     end;
  1714.                   end;
  1715.             'T' : begin {text}
  1716.                     if doexit or nextcommand then
  1717.                     begin
  1718.                       {$IFDEF DEBUGPAUSE}
  1719.                       readkey;
  1720.                       {$ENDIF}
  1721.                       s1 := unescapestring(tpos+1,bufcount);
  1722.                       rText(s1);
  1723.                       {$IFDEF DEBUGIT}
  1724.                       writeln(log,'Text: ',s1);
  1725.                       {$ENDIF}
  1726.                       resetparser2(c);
  1727.                       exit;
  1728.                     end;
  1729.                   end;
  1730.             '@' : begin {textxy}
  1731.                     if doexit or nextcommand then
  1732.                     begin
  1733.                       {$IFDEF DEBUGPAUSE}
  1734.                       readkey;
  1735.                       {$ENDIF}
  1736.                       s1 := unescapestring(tpos+5,bufcount);
  1737.                       w1 := megabuf(tpos,1,2);
  1738.                       w2 := megabuf(tpos,3,4);
  1739.                       rTextXY(w1,w2,s1);
  1740.                       {$IFDEF DEBUGIT}
  1741.                       writeln(log,'TextXY: ',w1,',',w2,',',s1);
  1742.                       {$ENDIF}
  1743.                       resetparser2(c);
  1744.                       exit;
  1745.                     end;
  1746.                   end;
  1747.             'Y' : begin {font style}
  1748.                     if bufcount = (tpos+ 8) then
  1749.                     begin
  1750.                       {$IFDEF DEBUGPAUSE}
  1751.                       readkey;
  1752.                       {$ENDIF}
  1753.                       b1 := megabuf(tpos,1,2);
  1754.                       b2 := megabuf(tpos,3,4);
  1755.                       b3 := megabuf(tpos,5,6);
  1756.                       rFontStyle(b1,b2,b3);
  1757.                       {$IFDEF DEBUGIT}
  1758.                       writeln(log,'Font Style: ',b1,',',b2,',',b3);
  1759.                       {$ENDIF}
  1760.                       resetparser;
  1761.                       exit;
  1762.                     end;
  1763.                   end;
  1764.             'X' : begin {pixel}
  1765.                     if bufcount = (tpos+ 4) then
  1766.                     begin
  1767.                       {$IFDEF DEBUGPAUSE}
  1768.                       readkey;
  1769.                       {$ENDIF}
  1770.                       w1 := megabuf(tpos,1,2);
  1771.                       w2 := megabuf(tpos,3,4);
  1772.                       rPixel(w1,w2);
  1773.                       {$IFDEF DEBUGIT}
  1774.                       writeln(log,'Pixel: ',w1,',',w2);
  1775.                       {$ENDIF}
  1776.                       resetparser;
  1777.                       exit;
  1778.                     end;
  1779.                   end;
  1780.             'L' : begin {line}
  1781.                     if bufcount = (tpos+ 8) then
  1782.                     begin
  1783.                       {$IFDEF DEBUGPAUSE}
  1784.                       readkey;
  1785.                       {$ENDIF}
  1786.                       w1 := megabuf(tpos,1,2);
  1787.                       w2 := megabuf(tpos,3,4);
  1788.                       w3 := megabuf(tpos,5,6);
  1789.                       w4 := megabuf(tpos,7,8);
  1790.                       rLine(w1,w2,w3,w4);
  1791.                       {$IFDEF DEBUGIT}
  1792.                       writeln(log,'Line: ',w1,',',w2,',',w3,',',w4);
  1793.                       {$ENDIF}
  1794.                       resetparser;
  1795.                       exit;
  1796.                     end;
  1797.                   end;
  1798.             'R' : begin {rectangle}
  1799.                     if bufcount = (tpos+ 8) then
  1800.                     begin
  1801.                       {$IFDEF DEBUGPAUSE}
  1802.                       readkey;
  1803.                       {$ENDIF}
  1804.                       w1 := megabuf(tpos,1,2);
  1805.                       w2 := megabuf(tpos,3,4);
  1806.                       w3 := megabuf(tpos,5,6);
  1807.                       w4 := megabuf(tpos,7,8);
  1808.                       rRectangle(w1,w2,w3,w4);
  1809.                       {$IFDEF DEBUGIT}
  1810.                       writeln(log,'Rectangle: ',w1,',',w2,',',w3,',',w4);
  1811.                       {$ENDIF}
  1812.                       resetparser;
  1813.                       exit;
  1814.                     end;
  1815.                   end;
  1816.             'B' : begin {bar}
  1817.                     if bufcount = (tpos+ 8) then
  1818.                     begin
  1819.                       {$IFDEF DEBUGPAUSE}
  1820.                       readkey;
  1821.                       {$ENDIF}
  1822.                       w1 := megabuf(tpos,1,2);
  1823.                       w2 := megabuf(tpos,3,4);
  1824.                       w3 := megabuf(tpos,5,6);
  1825.                       w4 := megabuf(tpos,7,8);
  1826.                       rBar(w1,w2,w3,w4);
  1827.                       {$IFDEF DEBUGIT}
  1828.                       writeln(log,'Bar: ',w1,',',w2,',',w3,',',w4);
  1829.                       {$ENDIF}
  1830.                       resetparser;
  1831.                       exit;
  1832.                     end;
  1833.                   end;
  1834.             'C' : begin {circle}
  1835.                     if bufcount = (tpos+ 6) then
  1836.                     begin
  1837.                       {$IFDEF DEBUGPAUSE}
  1838.                       readkey;
  1839.                       {$ENDIF}
  1840.                       w1 := megabuf(tpos,1,2);
  1841.                       w2 := megabuf(tpos,3,4);
  1842.                       w3 := megabuf(tpos,5,6);
  1843.                       rCircle(w1,w2,w3);
  1844.                       {$IFDEF DEBUGIT}
  1845.                       writeln(log,'Circle: ',w1,',',w2,',',w3);
  1846.                       {$ENDIF}
  1847.                       resetparser;
  1848.                       exit;
  1849.                     end;
  1850.                   end;
  1851.             'O' : begin {oval}
  1852.                     if bufcount = (tpos+ 12) then
  1853.                     begin
  1854.                       {$IFDEF DEBUGPAUSE}
  1855.                       readkey;
  1856.                       {$ENDIF}
  1857.                       w1 := megabuf(tpos,1,2);
  1858.                       w2 := megabuf(tpos,3,4);
  1859.                       w3 := megabuf(tpos,5,6);
  1860.                       w4 := megabuf(tpos,7,8);
  1861.                       w5 := megabuf(tpos,9,10);
  1862.                       w6 := megabuf(tpos,11,12);
  1863.                       rOval(w1,w2,w3,w4,w5,w6);
  1864.                       {$IFDEF DEBUGIT}
  1865.                       writeln(log,'Oval: ',w1,',',w2,',',w3,',',w4,',',w5,',',w6);
  1866.                       {$ENDIF}
  1867.                       resetparser;
  1868.                       exit;
  1869.                     end;
  1870.                   end;
  1871.             'o' : begin {filled oval}
  1872.                     if bufcount = (tpos+ 8) then
  1873.                     begin
  1874.                       {$IFDEF DEBUGPAUSE}
  1875.                       readkey;
  1876.                       {$ENDIF}
  1877.                       w1 := megabuf(tpos,1,2);
  1878.                       w2 := megabuf(tpos,3,4);
  1879.                       w3 := megabuf(tpos,5,6);
  1880.                       w4 := megabuf(tpos,7,8);
  1881.                       rFilledOval(w1,w2,w3,w4);
  1882.                       {$IFDEF DEBUGIT}
  1883.                       writeln(log,'Filled Oval: ',w1,',',w2,',',w3,',',w4);
  1884.                       {$ENDIF}
  1885.                       resetparser;
  1886.                       exit;
  1887.                     end;
  1888.                   end;
  1889.             'A' : begin {arc}
  1890.                     if bufcount = (tpos+ 10) then
  1891.                     begin
  1892.                       {$IFDEF DEBUGPAUSE}
  1893.                       readkey;
  1894.                       {$ENDIF}
  1895.                       w1 := megabuf(tpos,1,2);
  1896.                       w2 := megabuf(tpos,3,4);
  1897.                       w3 := megabuf(tpos,5,6);
  1898.                       w4 := megabuf(tpos,7,8);
  1899.                       w5 := megabuf(tpos,9,10);
  1900.                       rArc(w1,w2,w3,w4,w5);
  1901.                       {$IFDEF DEBUGIT}
  1902.                       writeln(log,'Arc: ',w1,',',w2,',',w3,',',w4,',',w5);
  1903.                       {$ENDIF}
  1904.                       resetparser;
  1905.                       exit;
  1906.                     end;
  1907.                   end;
  1908.             'V' : begin {oval arc}
  1909.                     if bufcount = (tpos+ 12) then
  1910.                     begin
  1911.                       {$IFDEF DEBUGPAUSE}
  1912.                       readkey;
  1913.                       {$ENDIF}
  1914.                       w1 := megabuf(tpos,1,2);
  1915.                       w2 := megabuf(tpos,3,4);
  1916.                       w3 := megabuf(tpos,5,6);
  1917.                       w4 := megabuf(tpos,7,8);
  1918.                       w5 := megabuf(tpos,9,10);
  1919.                       w6 := megabuf(tpos,11,12);
  1920.                       rOval(w1,w2,w3,w4,w5,w6);
  1921.                       {$IFDEF DEBUGIT}
  1922.                       writeln(log,'Oval Arc: ',w1,',',w2,',',w3,',',w4,',',w5,',',w6);
  1923.                       {$ENDIF}
  1924.                       resetparser;
  1925.                       exit;
  1926.                     end;
  1927.                   end;
  1928.             'I' : begin {pie slice}
  1929.                     if bufcount = (tpos+ 10) then
  1930.                     begin
  1931.                       {$IFDEF DEBUGPAUSE}
  1932.                       readkey;
  1933.                       {$ENDIF}
  1934.                       w1 := megabuf(tpos,1,2);
  1935.                       w2 := megabuf(tpos,3,4);
  1936.                       w3 := megabuf(tpos,5,6);
  1937.                       w4 := megabuf(tpos,7,8);
  1938.                       w5 := megabuf(tpos,9,10);
  1939.                       rPieSlice(w1,w2,w3,w4,w5);
  1940.                       {$IFDEF DEBUGIT}
  1941.                       writeln(log,'Pie Slice: ',w1,',',w2,',',w3,',',w4,',',w5);
  1942.                       {$ENDIF}
  1943.                       resetparser;
  1944.                       exit;
  1945.                     end;
  1946.                   end;
  1947.             'i' : begin {oval pie slice}
  1948.                     if bufcount = (tpos+ 12) then
  1949.                     begin
  1950.                       {$IFDEF DEBUGPAUSE}
  1951.                       readkey;
  1952.                       {$ENDIF}
  1953.                       w1 := megabuf(tpos,1,2);
  1954.                       w2 := megabuf(tpos,3,4);
  1955.                       w3 := megabuf(tpos,5,6);
  1956.                       w4 := megabuf(tpos,7,8);
  1957.                       w5 := megabuf(tpos,9,10);
  1958.                       w6 := megabuf(tpos,11,12);
  1959.                       rOvalPieSlice(w1,w2,w3,w4,w5,w6);
  1960.                       {$IFDEF DEBUGIT}
  1961.                       writeln(log,'Oval Pie Slice: ',w1,',',w2,',',w3,',',w4,',',w5,',',w6);
  1962.                       {$ENDIF}
  1963.                       resetparser;
  1964.                       exit;
  1965.                     end;
  1966.                   end;
  1967.             'Z' : begin {bezier}
  1968.                     if bufcount = (tpos+ 18) then
  1969.                     begin
  1970.                       {$IFDEF DEBUGPAUSE}
  1971.                       readkey;
  1972.                       {$ENDIF}
  1973.                       w1 := megabuf(tpos,1,2);
  1974.                       w2 := megabuf(tpos,3,4);
  1975.                       w3 := megabuf(tpos,5,6);
  1976.                       w4 := megabuf(tpos,7,8);
  1977.                       w5 := megabuf(tpos,9,10);
  1978.                       w6 := megabuf(tpos,11,12);
  1979.                       w7 := megabuf(tpos,13,14);
  1980.                       w8 := megabuf(tpos,15,16);
  1981.                       w9 := megabuf(tpos,17,18);
  1982.                       rBezier(w1,w2,w3,w4,w5,w6,w7,w8,w9);
  1983.                       {$IFDEF DEBUGIT}
  1984.                       writeln(log,'Bezier: ',w1,',',w2,',',w3,',',w4,',',w5,',',w6,',',w7,',',w8,',',w9);
  1985.                       {$ENDIF}
  1986.                       resetparser;
  1987.                       exit;
  1988.                     end;
  1989.                   end;
  1990.             'P' : begin {polygon}
  1991.                     if bufcount >= (tpos+ 2) then
  1992.                     begin
  1993.                       st2 := rbuffer[tpos+1]+rbuffer[tpos+2];
  1994.                       if bufcount = (tpos+2+ (4* megatoword(st2))) then
  1995.                       begin
  1996.                         {$IFDEF DEBUGPAUSE}
  1997.                         readkey;
  1998.                         {$ENDIF}
  1999.                         fillchar(temppoly,2048,#0);
  2000.                         w1 := megatoword(st2);
  2001.                         for sctr := 1 to w1 do
  2002.                         begin
  2003.                           temppoly[sctr].X := megabuf(tpos,3+((sctr-1)*4),4+((sctr-1)*4));
  2004.                           temppoly[sctr].Y := megabuf(tpos,5+((sctr-1)*4),6+((sctr-1)*4));
  2005.                         end;
  2006.                         rPolygon(w1,temppoly,true);
  2007.                         {$IFDEF DEBUGIT}
  2008.                         write(log,'Polygon: ',w1,',');
  2009.                         for sctr := 1 to w1 do
  2010.                           write(log,temppoly[sctr].X,',',temppoly[sctr].Y,',');
  2011.                         writeln(log);
  2012.                         {$ENDIF}
  2013.                         resetparser;
  2014.                         exit;
  2015.                       end;
  2016.                     end;
  2017.                   end;
  2018.             'p' : begin {fill polygon}
  2019.                     if bufcount >= (tpos+ 2) then
  2020.                     begin
  2021.                       st2 := rbuffer[tpos+1]+rbuffer[tpos+2];
  2022.                       if bufcount = (tpos+2+ (4* megatoword(st2))) then
  2023.                       begin
  2024.                         {$IFDEF DEBUGPAUSE}
  2025.                         readkey;
  2026.                         {$ENDIF}
  2027.                         fillchar(temppoly,2048,#0);
  2028.                         w1 := megatoword(st2);
  2029.                         for sctr := 1 to w1 do
  2030.                         begin
  2031.                           temppoly[sctr].X := megabuf(tpos,3+((sctr-1)*4),4+((sctr-1)*4));
  2032.                           temppoly[sctr].Y := megabuf(tpos,5+((sctr-1)*4),6+((sctr-1)*4));
  2033.                         end;
  2034.                         rFillPoly(w1,temppoly);
  2035.                         {$IFDEF DEBUGIT}
  2036.                         write(log,'Fill Polygon: ',w1,',');
  2037.                         for sctr := 1 to w1 do
  2038.                           write(log,temppoly[sctr].X,',',temppoly[sctr].Y,',');
  2039.                         writeln(log);
  2040.                         {$ENDIF}
  2041.                         resetparser;
  2042.                         exit;
  2043.                       end;
  2044.                     end;
  2045.                   end;
  2046.             'l' : begin {polyline}
  2047.                     if bufcount >= (tpos+ 2) then
  2048.                     begin
  2049.                       st2 := rbuffer[tpos+1]+rbuffer[tpos+2];
  2050.                       if bufcount = (tpos+2+ (4* megatoword(st2))) then
  2051.                       begin
  2052.                         {$IFDEF DEBUGPAUSE}
  2053.                         readkey;
  2054.                         {$ENDIF}
  2055.                         fillchar(temppoly,2048,#0);
  2056.                         w1 := megatoword(st2);
  2057.                         for sctr := 1 to w1 do
  2058.                         begin
  2059.                           temppoly[sctr].X := megabuf(tpos,3+((sctr-1)*4),4+((sctr-1)*4));
  2060.                           temppoly[sctr].Y := megabuf(tpos,5+((sctr-1)*4),6+((sctr-1)*4));
  2061.                         end;
  2062.                         rPolygon(w1,temppoly,false);
  2063.                         {$IFDEF DEBUGIT}
  2064.                         write(log,'PolyLine: ',w1,',');
  2065.                         for sctr := 1 to w1 to
  2066.                           write(log,temppoly[sctr].X,',',temppoly[sctr].Y,',');
  2067.                         writeln(log);
  2068.                         {$ENDIF}
  2069.                         resetparser;
  2070.                         exit;
  2071.                       end;
  2072.                     end;
  2073.                   end;
  2074.             'F' : begin {fill}
  2075.                     if bufcount = (tpos+ 6) then
  2076.                     begin
  2077.                       {$IFDEF DEBUGPAUSE}
  2078.                       readkey;
  2079.                       {$ENDIF}
  2080.                       w1 := megabuf(tpos,1,2);
  2081.                       w2 := megabuf(tpos,3,4);
  2082.                       w3 := megabuf(tpos,5,6);
  2083.                       rFill(w1,w2,w3);
  2084.                       {$IFDEF DEBUGIT}
  2085.                       writeln(log,'Fill: ',w1,',',w2,',',w3);
  2086.                       {$ENDIF}
  2087.                       resetparser;
  2088.                       exit;
  2089.                     end;
  2090.                   end;
  2091.             '=' : begin {line style}
  2092.                     if bufcount = (tpos+ 8) then
  2093.                     begin
  2094.                       {$IFDEF DEBUGPAUSE}
  2095.                       readkey;
  2096.                       {$ENDIF}
  2097.                       w1 := megabuf(tpos,1,2);
  2098.                       w2 := word(mega4tolong(rbuffer[tpos+3]+rbuffer[tpos+4]
  2099.                                             +rbuffer[tpos+5]+rbuffer[tpos+6]));
  2100.                       w3 := megabuf(tpos,7,8);
  2101.                       rLineStyle(w1,w2,w3);
  2102.                       {$IFDEF DEBUGIT}
  2103.                       writeln(log,'Line Style: ',w1,',',w2,',',w3);
  2104.                       {$ENDIF}
  2105.                       resetparser;
  2106.                       exit;
  2107.                     end;
  2108.                   end;
  2109.             'S' : begin {fill style}
  2110.                     if bufcount = (tpos+ 4) then
  2111.                     begin
  2112.                       {$IFDEF DEBUGPAUSE}
  2113.                       readkey;
  2114.                       {$ENDIF}
  2115.                       w1 := megabuf(tpos,1,2);
  2116.                       w2 := megabuf(tpos,3,4);
  2117.                       rFillStyle(w1,w2);
  2118.                       {$IFDEF DEBUGIT}
  2119.                       writeln(log,'Fill Style: ',w1,',',w2);
  2120.                       {$ENDIF}
  2121.                       resetparser;
  2122.                       exit;
  2123.                     end;
  2124.                   end;
  2125.             's' : begin {fill pattern}
  2126.                     if bufcount = (tpos+ 18) then
  2127.                     begin
  2128.                       DoFillPattern;
  2129.                       resetparser;
  2130.                       exit;
  2131.                     end;
  2132.                   end;
  2133.             '#' : begin {no more}
  2134.                     {$IFDEF DEBUGPAUSE}
  2135.                     readkey;
  2136.                     {$ENDIF}
  2137.                     {$IFDEF DEBUGIT}
  2138.                     writeln(log,'No More');
  2139.                     {$ENDIF}
  2140.                     resetparser2(c);
  2141.                     exit;
  2142.                   end;
  2143.             else
  2144.             begin
  2145.               dumpbuffer;
  2146.               exit;
  2147.             end;
  2148.           end;
  2149.         end;
  2150.         1  : begin
  2151.           case command of
  2152.             'M' : begin {mouse}
  2153.                     if doexit or nextcommand then
  2154.                     begin
  2155.                       {$IFDEF DEBUGPAUSE}
  2156.                       readkey;
  2157.                       {$ENDIF}
  2158.                       s1 := unescapestring(tpos+18,bufcount);
  2159.                       w1 := megabuf(tpos,3,4);
  2160.                       w2 := megabuf(tpos,5,6);
  2161.                       w3 := megabuf(tpos,7,8);
  2162.                       w4 := megabuf(tpos,9,10);
  2163.                       o1 := megab(rbuffer[tpos+11]);
  2164.                       o2 := megab(rbuffer[tpos+12]);
  2165.                       rMouse(w1,w2,w3,w4,o1,o2,s1);
  2166.                       {$IFDEF DEBUGIT}
  2167.                       writeln(log,'Mouse: ',w1,',',w2,',',w3,',',w4,',',o1,',',o2,',',s1);
  2168.                       {$ENDIF}
  2169.                       resetparser2(c);
  2170.                       exit;
  2171.                     end;
  2172.                   end;
  2173.             'K' : begin {kill mouse fields}
  2174.                     {$IFDEF DEBUGPAUSE}
  2175.                     readkey;
  2176.                     {$ENDIF}
  2177.                     rKillMouse;
  2178.                     {$IFDEF DEBUGIT}
  2179.                     writeln(log,'Kill Mouse Fields');
  2180.                     {$ENDIF}
  2181.                     resetparser2(c);
  2182.                     exit;
  2183.                   end;
  2184.             'T' : begin {begin text}
  2185.                     if bufcount = (tpos+ 10) then
  2186.                     begin
  2187.                       {$IFDEF DEBUGPAUSE}
  2188.                       readkey;
  2189.                       {$ENDIF}
  2190.                       {$IFDEF DEBUGIT}
  2191.                       writeln(log,'Begin Text: x');
  2192.                       {$ENDIF}
  2193.                       resetparser;
  2194.                       exit;
  2195.                     end;
  2196.                   end;
  2197.             't' : begin {region text}
  2198.                     if doexit or nextcommand then
  2199.                     begin
  2200.                       {$IFDEF DEBUGPAUSE}
  2201.                       readkey;
  2202.                       {$ENDIF}
  2203.                       {$IFDEF DEBUGIT}
  2204.                       writeln(log,'Region Text: x');
  2205.                       {$ENDIF}
  2206.                       resetparser2(c);
  2207.                       exit;
  2208.                     end;
  2209.                   end;
  2210.             'E' : begin {end text}
  2211.                     {$IFDEF DEBUGPAUSE}
  2212.                     readkey;
  2213.                     {$ENDIF}
  2214.                     {$IFDEF DEBUGIT}
  2215.                     writeln(log,'End Text');
  2216.                     {$ENDIF}
  2217.                     resetparser2(c);
  2218.                     exit;
  2219.                   end;
  2220.             'C' : begin {get image}
  2221.                     if bufcount = (tpos+ 9) then
  2222.                     begin
  2223.                       {$IFDEF DEBUGPAUSE}
  2224.                       readkey;
  2225.                       {$ENDIF}
  2226.                       w1 := megabuf(tpos,1,2);
  2227.                       w2 := megabuf(tpos,3,4);
  2228.                       w3 := megabuf(tpos,5,6);
  2229.                       w4 := megabuf(tpos,7,8);
  2230.                       rGetImage(w1,w2,w3,w4);
  2231.                       {$IFDEF DEBUGIT}
  2232.                       writeln(log,'Get Image: ',w1,',',w2,',',w3,',',w4);
  2233.                       {$ENDIF}
  2234.                       resetparser;
  2235.                       exit;
  2236.                     end;
  2237.                   end;
  2238.             'P' : begin {put image}
  2239.                     if bufcount = (tpos+ 7) then
  2240.                     begin
  2241.                       {$IFDEF DEBUGPAUSE}
  2242.                       readkey;
  2243.                       {$ENDIF}
  2244.                       w1 := megabuf(tpos,1,2);
  2245.                       w2 := megabuf(tpos,3,4);
  2246.                       w3 := megabuf(tpos,5,6);
  2247.                       rPutImage(w1,w2,w3);
  2248.                       {$IFDEF DEBUGIT}
  2249.                       writeln(log,'Put Image: ',w1,',',w2,',',w3);
  2250.                       {$ENDIF}
  2251.                       resetparser;
  2252.                       exit;
  2253.                     end;
  2254.                   end;
  2255.             'W' : begin {write icon}
  2256.                     if doexit or nextcommand then
  2257.                     begin
  2258.                       {$IFDEF DEBUGPAUSE}
  2259.                       readkey;
  2260.                       {$ENDIF}
  2261.                       s1 := unescapestring(tpos+2,bufcount);
  2262.                       rWriteIcon(s1);
  2263.                       {$IFDEF DEBUGIT}
  2264.                       writeln(log,'Write Icon: ',s1);
  2265.                       {$ENDIF}
  2266.                       resetparser2(c);
  2267.                       exit;
  2268.                     end;
  2269.                   end;
  2270.             'I' : begin {load icon}
  2271.                     if doexit or nextcommand then
  2272.                     begin
  2273.                       {$IFDEF DEBUGPAUSE}
  2274.                       readkey;
  2275.                       {$ENDIF}
  2276.                       s1 := unescapestring(tpos+10,bufcount);
  2277.                       w1 := megabuf(tpos,1,2);
  2278.                       w2 := megabuf(tpos,3,4);
  2279.                       w3 := megabuf(tpos,5,6);
  2280.                       o1 := megab(rbuffer[tpos+7]);
  2281.                       rLoadIcon(w1,w2,w3,o1,s1);
  2282.                       {$IFDEF DEBUGIT}
  2283.                       writeln(log,'Load Icon: ',w1,',',w2,',',w3,',',o1,',',s1);
  2284.                       {$ENDIF}
  2285.                       resetparser2(c);
  2286.                       exit;
  2287.                     end;
  2288.                   end;
  2289.             'B' : begin {button style}
  2290.                     if bufcount = (tpos+ 36) then
  2291.                     begin
  2292.                       DoTheButtonStyle;
  2293.                       resetparser;
  2294.                       exit;
  2295.                     end;
  2296.                   end;
  2297.             'U' : begin {button}
  2298.                     if doexit or nextcommand then
  2299.                     begin
  2300.                       DoTheButton;
  2301.                       resetparser2(c);
  2302.                       exit;
  2303.                     end;
  2304.                   end;
  2305.             'D' : begin {define}
  2306.                     if doexit or nextcommand then
  2307.                     begin
  2308.                       {$IFDEF DEBUGPAUSE}
  2309.                       readkey;
  2310.                       {$ENDIF}
  2311.                       {$IFDEF DEBUGIT}
  2312.                       writeln(log,'Define: x');
  2313.                       {$ENDIF}
  2314.                       resetparser2(c);
  2315.                       exit;
  2316.                     end;
  2317.                   end;
  2318.             #27 : begin {query}
  2319.                     if doexit or nextcommand then
  2320.                     begin
  2321.                       {$IFDEF DEBUGPAUSE}
  2322.                       readkey;
  2323.                       {$ENDIF}
  2324.                       {$IFDEF DEBUGIT}
  2325.                       writeln(log,'Query: x');
  2326.                       {$ENDIF}
  2327.                       resetparser2(c);
  2328.                       exit;
  2329.                     end;
  2330.                   end;
  2331.             'G' : begin {copy region}
  2332.                     if bufcount = (tpos+ 12) then
  2333.                     begin
  2334.                       {$IFDEF DEBUGPAUSE}
  2335.                       readkey;
  2336.                       {$ENDIF}
  2337.                       {$IFDEF DEBUGIT}
  2338.                       writeln(log,'Copy Region: x');
  2339.                       {$ENDIF}
  2340.                       resetparser;
  2341.                       exit;
  2342.                     end;
  2343.                   end;
  2344.             'R' : begin {read scene}
  2345.                     if doexit or nextcommand then
  2346.                     begin
  2347.                       {$IFDEF DEBUGPAUSE}
  2348.                       readkey;
  2349.                       {$ENDIF}
  2350.                       {$IFDEF DEBUGIT}
  2351.                       writeln(log,'Read Scene: x');
  2352.                       {$ENDIF}
  2353.                       resetparser2(c);
  2354.                       exit;
  2355.                     end;
  2356.                   end;
  2357.             'F' : begin {file query}
  2358.                     if doexit or nextcommand then
  2359.                     begin
  2360.                       {$IFDEF DEBUGPAUSE}
  2361.                       readkey;
  2362.                       {$ENDIF}
  2363.                       {$IFDEF DEBUGIT}
  2364.                       writeln(log,'File Query: x');
  2365.                       {$ENDIF}
  2366.                       resetparser2(c);
  2367.                       exit;
  2368.                     end;
  2369.                   end;
  2370.             else
  2371.             begin
  2372.               dumpbuffer;
  2373.               exit;
  2374.             end;
  2375.           end;
  2376.         end;
  2377.         9  : begin
  2378.           case command of
  2379.             #27 : begin {enter block mode}
  2380.                     if doexit or nextcommand then
  2381.                     begin
  2382.                       {$IFDEF DEBUGPAUSE}
  2383.                       readkey;
  2384.                       {$ENDIF}
  2385.                       {$IFDEF DEBUGIT}
  2386.                       writeln(log,'Block Mode: x');
  2387.                       {$ENDIF}
  2388.                       resetparser2(c);
  2389.                       exit;
  2390.                     end;
  2391.                   end;
  2392.             else
  2393.             begin
  2394.               dumpbuffer;
  2395.               exit;
  2396.             end;
  2397.           end;
  2398.         end;
  2399.         else {case}
  2400.         begin
  2401.           dumpbuffer;
  2402.           exit;
  2403.         end;
  2404.       end; {case level of}
  2405.       if doexit then
  2406.         exit;
  2407.     end; {got_command}
  2408.   end;
  2409.   doripchar := true;
  2410. end;
  2411.  
  2412. {$IFDEF MOUSE}
  2413. Procedure RipObj.MouseInit;
  2414. begin
  2415.   regs.ax := $0000;
  2416.   intr($33,regs);
  2417.   mouseexist := (regs.ax = $ffff);
  2418.   ismouseon := false;
  2419.   fillchar(regionarray,sizeof(mouseregionrecord)*128,#0);
  2420.   lastbutton := 0;
  2421.   inverted := 0;
  2422.   fillchar(keybuf,250,#0);
  2423.   keybufhead := 1;
  2424.   keybuftail := 1;
  2425.   LastStatus := 0;
  2426.   LastX := 0;
  2427.   LastY := 0;
  2428. end;
  2429.  
  2430. Procedure RipObj.MouseOn;
  2431. begin
  2432.   if not mouseexist then
  2433.     exit;
  2434.   if ismouseon then
  2435.     exit;
  2436.   regs.ax := $01;
  2437.   intr($33,regs);
  2438.   ismouseon := true;
  2439. end;
  2440.  
  2441. Procedure RipObj.MouseOff;
  2442. begin
  2443.   if not mouseexist then
  2444.     exit;
  2445.   if not ismouseon then
  2446.     exit;
  2447.   regs.ax := $02;
  2448.   intr($33,regs);
  2449.   ismouseon := false;
  2450. end;
  2451.  
  2452. Procedure RipObj.GetPosition(var ButtonStatus,xPos,yPos:Integer);
  2453. {absolute coords}
  2454. {ButtonStatus : Bit 0 - Left Button is down
  2455.                 Bit 1 - Right Button is down
  2456.                 Bit 2 - Middle Button is down }
  2457. begin
  2458.   if not mouseexist then
  2459.     exit;
  2460.   regs.ax := $03;
  2461.   intr($33,regs);
  2462.   buttonstatus := regs.bx;
  2463.   xpos := regs.cx;
  2464.   ypos := regs.dx;
  2465. end;
  2466.  
  2467. Procedure RipObj.SetMousePos(x,y:Integer);
  2468. {absolute coords}
  2469. begin
  2470.   if not mouseexist then
  2471.     exit;
  2472.   regs.ax := $04;
  2473.   regs.cx := x;
  2474.   regs.dx := y;
  2475.   intr($33,regs);
  2476. end;
  2477.  
  2478. Procedure RipObj.IsButtonDown(Button:Integer; var Status,DnCount,xPos,yPos:Integer);
  2479. begin
  2480.   if not mouseexist then
  2481.     exit;
  2482.   regs.ax := $05;
  2483.   regs.bx := button;
  2484.   intr($33,regs);
  2485.   status := regs.ax;
  2486.   dncount := regs.bx;
  2487.   xpos := regs.cx;
  2488.   ypos := regs.dx;
  2489. end;
  2490.  
  2491. Procedure RipObj.IsButtonUp(Button:Integer; var Status,UpCount,xPos,yPos:Integer);
  2492. begin
  2493.   if not mouseexist then
  2494.     exit;
  2495.   regs.ax := $06;
  2496.   regs.bx := button;
  2497.   intr($33,regs);
  2498.   status := regs.ax;
  2499.   upcount := regs.bx;
  2500.   xpos := regs.cx;
  2501.   ypos := regs.dx;
  2502. end;
  2503.  
  2504. Function FlagOn(Flags : word; FlagMask : word) : Boolean;
  2505. begin
  2506.   FlagOn := (Flags and FlagMask) <> 0;
  2507. end;
  2508.  
  2509. Procedure RipObj.CheckMouse;
  2510. { ax : intrmask (see below)
  2511.   bx : button status
  2512.   cx : current x position
  2513.   dx : current y position}
  2514. var
  2515.   bx,cx,dx : integer;
  2516. begin
  2517.   if not mouseexist then
  2518.     exit;
  2519.   GetPosition(bx,cx,dx);
  2520.   if flagon(bx,$1) and (not flagon(laststatus,$1)) then {if leftbutton just pushed}
  2521.   begin
  2522.     curregion := inregion(cx,dx);
  2523.     if curregion <> 0 then
  2524.     begin
  2525.       if regionarray[curregion].invert then
  2526.       begin
  2527.         inverted := curregion;
  2528.         doinvert(curregion,true);
  2529.       end;
  2530.       curbutton := curregion;
  2531.     end
  2532.     else
  2533.       curbutton := 0;
  2534.   end;
  2535.  
  2536.   if flagon(bx,$1) and flagon(laststatus,$1) then {if leftbutton down and not just pushed}
  2537.   begin
  2538.     CurRegion := InRegion(cx,dx);
  2539.     if curregion = curbutton then
  2540.     begin
  2541.       if (inverted <> curbutton) and regionarray[curregion].invert then
  2542.       begin
  2543.         doinvert(curregion,true);
  2544.         inverted := curregion;
  2545.       end;
  2546.     end
  2547.     else
  2548.     begin
  2549.       if inverted <> 0 then
  2550.       begin
  2551.         doinvert(curbutton,false);
  2552.         inverted := 0;
  2553.       end;
  2554.     end;
  2555.   end;
  2556.  
  2557.   if (not flagon(bx,$1)) and flagon(laststatus,$1) and (curbutton <> 0) then
  2558.   {if leftbutton just released then}
  2559.   begin
  2560.     curregion := inregion(cx,dx);
  2561.     if curregion = curbutton then
  2562.     begin
  2563.       if regionarray[curregion].invert then
  2564.         doinvert(curbutton,false);
  2565.       if regionarray[curbutton].reset then
  2566.       begin
  2567.         {do |!*}
  2568.       end;
  2569.       addstring(regionarray[curbutton].thetext);
  2570.     end;
  2571.     inverted := 0;
  2572.     curbutton := 0;
  2573.   end;
  2574.   laststatus := bx;
  2575.   lastx := cx;
  2576.   lasty := dx;
  2577. end;
  2578.  
  2579. Function RipObj.InRegion(x,y:word):byte;
  2580. var
  2581.   c : byte;
  2582. begin
  2583.   if not mouseexist then
  2584.     exit;
  2585.   for c := lastbutton downto 1 do
  2586.   begin
  2587.     inregion := c;
  2588.     with regionarray[c] do
  2589.     begin
  2590.       if (x >= x0) and (x <= x1) and (y >= y0) and (y <= y1) then
  2591.         exit;
  2592.     end;
  2593.   end;
  2594.   inregion := 0;
  2595. end;
  2596.  
  2597. Procedure RipObj.DoInvert(region:byte;InvertIt:boolean);
  2598. var
  2599.   cb : pointer;
  2600.   cbsize : word;
  2601.   wason : boolean;
  2602. begin
  2603.   if not mouseexist then
  2604.     exit;
  2605.   with regionarray[region] do
  2606.   begin
  2607.     wason := ismouseon;
  2608.     if wason then
  2609.       MouseOff;
  2610.     cbsize := imagesize(x0,y0,x1,y1);
  2611.     getmem(cb,cbsize);
  2612.     getimage(x0,y0,x1,y1,cb^);
  2613.     putimage(x0,y0,cb^,4{NOT});
  2614.     freemem(cb,cbsize);
  2615.     if wason then
  2616.       MouseOn;
  2617.   end;
  2618. end;
  2619.  
  2620. Procedure RipObj.AddRegion(x0,y0,x1,y1:word;invert,reset:boolean;thetext:str50);
  2621. begin
  2622.   if not mouseexist then
  2623.     exit;
  2624.   inc(lastbutton);
  2625.   regionarray[lastbutton].x0      := x0;
  2626.   regionarray[lastbutton].y0      := y0;
  2627.   regionarray[lastbutton].x1      := x1;
  2628.   regionarray[lastbutton].y1      := y1;
  2629.   regionarray[lastbutton].invert  := invert;
  2630.   regionarray[lastbutton].reset   := reset;
  2631.   regionarray[lastbutton].thetext := thetext;
  2632. end;
  2633.  
  2634. Function RipObj.CharInBuffer: boolean;
  2635. begin
  2636.   if not mouseexist then
  2637.   begin
  2638.     charinbuffer := false;
  2639.     exit;
  2640.   end;
  2641.   CharInBuffer := KeyBufHead <> KeyBufTail;
  2642. end;
  2643.  
  2644. Function RipObj.GetNextChar:char;
  2645. begin
  2646.   getnextchar := #0;
  2647.   if not mouseexist then
  2648.     exit;
  2649.   if KeyBufHead <> KeyBufTail then
  2650.   begin
  2651.     getnextchar := keybuf[keybufhead];
  2652.     inc(keybufhead);
  2653.     if keybufhead > 250 then
  2654.       keybufhead := 1;
  2655.   end;
  2656. end;
  2657.  
  2658. Procedure RipObj.AddString(st:string);
  2659. var
  2660.   s : string;
  2661.   c : byte;
  2662. begin
  2663.   if not mouseexist then
  2664.     exit;
  2665.   c := 0;
  2666.   s := '';
  2667.   while c < length(st) do
  2668.   begin
  2669.     inc(c);
  2670.     if st[c] = '^' then
  2671.     begin
  2672.       inc(c);
  2673.       if upcase(st[c]) in ['A'..'Z'] then
  2674.       begin
  2675.         s := s + char(byte(upcase(st[c]))-64);
  2676.       end
  2677.       else
  2678.       begin
  2679.         s := s + '^' + st[c];
  2680.       end;
  2681.     end
  2682.     else
  2683.     begin
  2684.       s := s + st[c];
  2685.     end;
  2686.   end;
  2687.   for c := 1 to length(s) do
  2688.   begin
  2689.     KeyBuf[KeyBufTail] := s[c];
  2690.     inc(keybuftail);
  2691.     if keybuftail > 250 then
  2692.       keybuftail := 1;
  2693.   end;
  2694. end;
  2695.  
  2696. Procedure RipObj.KillRegions;
  2697. begin
  2698.   if not mouseexist then
  2699.     exit;
  2700.   fillchar(regionarray,sizeof(mouseregionrecord)*128,#0);
  2701.   lastbutton := 0;
  2702. end;
  2703.  
  2704. Procedure RipObj.KillBuffer;
  2705. begin
  2706.   if not mouseexist then
  2707.     exit;
  2708.   fillchar(keybuf,250,#0);
  2709.   keybufhead := 1;
  2710.   keybuftail := 1;
  2711. end;
  2712. {$ENDIF}
  2713.  
  2714. Procedure DoNada;
  2715. var
  2716.   thevar,
  2717.   thevar2 : string;
  2718. begin
  2719.   thevar := theripcopyright;
  2720.   thevar2 := theripcopyright2;
  2721. end;
  2722.  
  2723. {*** Ansi Emulator***}
  2724.  
  2725. procedure RipObj.PutQueue(C : Char);
  2726. begin
  2727.   if QueueIndex < QueueSize then
  2728.   begin
  2729.     Inc(QueueIndex);
  2730.     Queue^[QueueIndex] := C;
  2731.   end;
  2732. end;
  2733.  
  2734. procedure RipObj.ProcessChar(C : Char; var pCommand : CommandRecord);
  2735.  
  2736.   procedure ErrorCondition;
  2737.   begin
  2738.     pCommand.Cmd := eError;
  2739.     InitParser;
  2740.   end;
  2741.  
  2742. begin
  2743.   PutQueue(C);         {put char in queue in case of subsequent error}
  2744.   with pCommand do
  2745.   begin
  2746.     Ch := C;
  2747.     Cmd := eNone;
  2748.   end;
  2749.   case ParserState of
  2750.     GotNone :
  2751.       if C = Escape then
  2752.         ParserState := GotEscape
  2753.       else
  2754.         if C = FormFeed then
  2755.           pCommand.Cmd := eClearScreen
  2756.         else
  2757.           pCommand.Cmd := eChar;
  2758.     GotEscape :
  2759.       if C = LeftBracket then
  2760.         ParserState := GotBracket
  2761.       else
  2762.         ErrorCondition;
  2763.     GotParam,
  2764.     GotBracket,
  2765.     GotSemicolon :       {need a parameter char, semicolon or command}
  2766.       if (C >= #48) and (C <= #57) then
  2767.       begin
  2768.         BuildParam(C);
  2769.         ParserState := GotParam;
  2770.       end
  2771.       else
  2772.       begin
  2773.         if C = Semicolon then
  2774.         begin
  2775.           if ParserState = GotSemicolon then
  2776.             ErrorCondition
  2777.           else
  2778.           begin
  2779.             ParserState := GotSemicolon;
  2780.             Inc(ParamIndex);
  2781.             if ParamIndex > AnsiMaxParams then
  2782.               ErrorCondition;
  2783.           end;
  2784.         end
  2785.         else
  2786.         begin
  2787.           MakeCommand(C, pCommand);
  2788.           InitParser;
  2789.         end;
  2790.       end;
  2791.   end;
  2792. end;
  2793.  
  2794. procedure RipObj.InitParser;
  2795. begin
  2796.   ParamIndex := 1;
  2797.   FillChar(Params,SizeOf(Params),0);
  2798.   ParserState := GotNone;
  2799.   QueueIndex := 0;
  2800. end;
  2801.  
  2802. procedure RipObj.BuildParam(C : Char);
  2803. begin
  2804.   Params[ParamIndex] := Params[ParamIndex] + C;
  2805. end;
  2806.  
  2807. procedure RipObj.ConvertParams(C : Char);
  2808. var
  2809.   I, Code : Integer;
  2810. begin
  2811.   for I := 1 to AnsiMaxParams do
  2812.   begin
  2813.     Val(Params[I], ParamInt[I], Code);
  2814.     if Code <> 0 then
  2815.       ParamInt[I] := 1;
  2816.   end;
  2817.   if (Length(Params[1]) = 0) and (C in ['J', 'K']) then
  2818.     ParamInt[1] := 2;
  2819. end;
  2820.  
  2821. procedure RipObj.MakeCommand(C : Char; var pCommand : CommandRecord);
  2822. var
  2823.   I, TextFg, TextBk : Byte;
  2824. begin
  2825.   ConvertParams(C);
  2826.   with pCommand do
  2827.   begin
  2828.     Ch := C;
  2829.     case C of
  2830.       'f', 'H' : begin
  2831.         Cmd := eGotoXY;
  2832.         X   := ParamInt[2];
  2833.         Y   := ParamInt[1];
  2834.       end;
  2835.       'A' : begin
  2836.         Cmd := eUp;
  2837.         Y   := ParamInt[1];
  2838.       end;
  2839.       'B' : begin
  2840.         Cmd := eDown;
  2841.         Y   := ParamInt[1];
  2842.       end;
  2843.       'C' : begin
  2844.         Cmd := eRight;
  2845.         X   := ParamInt[1];
  2846.       end;
  2847.       'D' : begin
  2848.         cmd := eLeft;
  2849.         X   := ParamInt[1];
  2850.       end;
  2851.       'J' : begin
  2852.         case ParamInt[1] of
  2853.           0 : Cmd := eClearBelow;
  2854.           1 : Cmd := eClearAbove;
  2855.           2 : Cmd := eClearScreen;
  2856.           else
  2857.             Cmd := eChar;
  2858.         end;
  2859.       end;
  2860.       'K' : begin
  2861.         case ParamInt[1] of
  2862.           0 : Cmd := eClearEndOfLine;
  2863.           1 : Cmd := eClearStartOfLine;
  2864.           2 : Cmd := eClearLine;
  2865.           else
  2866.             Cmd := eChar;
  2867.         end;
  2868.       end;
  2869.       'h' : begin
  2870.         Cmd := eSetMode;
  2871.         X   := ParamInt[1];
  2872.       end;
  2873.       'm' : begin
  2874.         Cmd := eSetAttribute;
  2875.         X   := aTextAttr;
  2876.         for I := 1 to ParamIndex do
  2877.         begin
  2878.           if Inverse then
  2879.           begin
  2880.             Blink := X and $80 = $80;
  2881.             Intense := X and $08 = $08;
  2882.             X := X and $77;
  2883.  
  2884.             X := Byte((Word(X) shl 4) or (Word(X) shr 4));
  2885.           end;
  2886.  
  2887.           TextFg := X and $0F;
  2888.           TextBk := X and $F0;
  2889.  
  2890.           case ParamInt[I] of
  2891.             0  : begin
  2892.                    X := $07;            {White on black}
  2893.                    Inverse := False;
  2894.                    Intense := False;
  2895.                    Blink := False;
  2896.                    Invis := False;
  2897.                  end;
  2898.             1  : Intense  := True;      {Set intense bit later}
  2899.             4  : Intense  := True;      {Subst intense for underline}
  2900.             5  : Blink := True;         {set blinking on}
  2901.             7  : Inverse  := True;      {Invert TextAttr later}
  2902.             8  : Invis := True;         {Invisible}
  2903.             27 : Inverse  := False;     {Stop inverting TextAttr}
  2904.             30 : X := TextBk or $00;    {Black foreground}
  2905.             31 : X := TextBk or $04;    {Red foreground}
  2906.             32 : X := TextBk or $02;    {Green foreground}
  2907.             33 : X := TextBk or $06;    {Yellow forground}
  2908.             34 : X := TextBk or $01;    {Blue foreground}
  2909.             35 : X := TextBk or $05;    {Magenta foreground}
  2910.             36 : X := TextBk or $03;    {Cyan foreground}
  2911.             37 : X := TextBk or $07;    {White foreground}
  2912.             40 : X := TextFg;
  2913.             41 : X := TextFg or $40;    {Red background}
  2914.             42 : X := TextFg or $20;    {Green background}
  2915.             43 : X := TextFg or $60;    {Yellow background}
  2916.             44 : X := TextFg or $10;    {Blue background}
  2917.             45 : X := TextFg or $50;    {Magenta background}
  2918.             46 : X := TextFg or $30;    {Cyan background}
  2919.             47 : X := TextFg or $70;    {White background}
  2920.           end;
  2921.         end;
  2922.  
  2923.         if Inverse then
  2924.           X := Byte((Word(X) shl 4) or (Word(X) shr 4));
  2925.         if Inverse then
  2926.           X := X and $7F;
  2927.         if Invis then
  2928.           X := $00;
  2929.         if Intense then
  2930.           X := X or $08;
  2931.         if Blink then
  2932.           X := X or $80;
  2933.         aTextAttr := X;
  2934.       end;
  2935.       's' : Cmd := eSaveCursorPos;
  2936.       'u' : Cmd := eRestoreCursorPos;
  2937.       'n' : cmd := eDeviceStatusReport;
  2938.       else
  2939.         Cmd := eError;
  2940.     end;
  2941.   end;
  2942. end;
  2943.  
  2944. {*** Text Window Methods ***}
  2945.  
  2946. Procedure RipObj.DoTextStr(s:string);
  2947. var
  2948.   ctr : byte;
  2949. begin
  2950.   for ctr := 1 to length(s) do
  2951.     DoTextChar(s[ctr]);
  2952. end;
  2953.  
  2954. Procedure RipObj.DoTextChar(c:char);
  2955. {General processing procedure for text window}
  2956. var
  2957.   fst : fillsettingstype;
  2958.   ctr : byte;
  2959. begin
  2960.   ProcessChar(c,CmdRec);
  2961.   case CmdRec.Cmd of
  2962.     eNone               : ;
  2963.     eChar               : if localrip and textactive then DispChar(CmdRec.Ch);
  2964.     eGotoXY             : rGotoXY(CmdRec.X,CmdRec.Y);
  2965.     eUp                 : begin {cursor up}
  2966.       if cursory-CmdRec.x >= texty0 then
  2967.         rGotoXY(cursorx,cursory-CmdRec.x);
  2968.     end;
  2969.     eDown               : begin {cursor down}
  2970.       if cursory+CmdRec.x <= texty1 then
  2971.         rGotoXY(cursorx,cursory+CmdRec.x);
  2972.     end;
  2973.     eRight              : begin {cursor right}
  2974.       if cursorx+CmdRec.x <= textx1 then
  2975.         rGotoXY(cursorx+CmdRec.x,cursory);
  2976.     end;
  2977.     eLeft               : begin {cursor left}
  2978.       if cursorx-CmdRec.x >= textx0 then
  2979.         rGotoXY(cursorx-CmdRec.x,cursory);
  2980.     end;
  2981.     eClearBelow         : ; {clear screen below cursor}
  2982.     eClearAbove         : ; {clear screen above cursor}
  2983.     eClearScreen        : begin {clear entire screen}
  2984.       if LocalRip and TextActive then
  2985.       begin
  2986.         {$IFDEF MOUSE}
  2987.         MouseOff;
  2988.         {$ENDIF}
  2989.         getfillsettings(fst);
  2990.         setfillstyle(0,textclr and $F0);
  2991.         fillchar(virtualwindow,7826,#0);
  2992.         Bar(TextOffsetX[textsize]*textx0,TextOffsetY[textsize]*texty0,
  2993.             TextOffsetX[textsize]*(textx1+1)-1,TextOffsetY[textsize]*(texty1+1)-1);
  2994.         setfillstyle(fst.pattern,fst.color);
  2995.         rHome;
  2996.         {$IFDEF MOUSE}
  2997.         MouseOn;
  2998.         {$ENDIF}
  2999.       end;
  3000.     end;
  3001.     eClearEndofLine     : begin {clear from cursor to end of line}
  3002.       if LocalRip and TextActive then
  3003.       begin
  3004.         {$IFDEF MOUSE}
  3005.         MouseOff;
  3006.         {$ENDIF}
  3007.         getfillsettings(fst);
  3008.         setfillstyle(0,textclr and $F0);
  3009.         Bar(TextOffsetX[textsize]*cursorx,TextOffsetY[textsize]*cursory,
  3010.             TextOffsetX[textsize]*(textx1+1)-1,TextOffsetY[textsize]*(cursory+1)-1);
  3011.         for ctr := cursorx to TextMaxX[textsize] do
  3012.           virtualwindow[ctr,cursory,0] := 0;
  3013.         setfillstyle(fst.pattern,fst.color);
  3014.         rHome;
  3015.         {$IFDEF MOUSE}
  3016.         MouseOn;
  3017.         {$ENDIF}
  3018.       end;
  3019.     end;
  3020.     eClearStartOfLine   : ; {clear from cursor to the start of line}
  3021.     eClearLine          : begin {clear entire line that cursor is on}
  3022.       if LocalRip and TextActive then
  3023.       begin
  3024.         {$IFDEF MOUSE}
  3025.         MouseOff;
  3026.         {$ENDIF}
  3027.         getfillsettings(fst);
  3028.         setfillstyle(0,textclr and $F0);
  3029.         Bar(TextOffsetX[textsize]*textx0,TextOffsetY[textsize]*cursory,
  3030.             TextOffsetX[textsize]*(textx1+1)-1,TextOffsetY[textsize]*(cursory+1)-1);
  3031.         for ctr := 0 to TextMaxX[textsize] do
  3032.           virtualwindow[ctr,cursory,0] := 0;
  3033.         setfillstyle(fst.pattern,fst.color);
  3034.         rHome;
  3035.         {$IFDEF MOUSE}
  3036.         MouseOn;
  3037.         {$ENDIF}
  3038.       end;
  3039.     end;
  3040.     eSetAttribute       : textclr := CmdRec.X;
  3041.     eSaveCursorPos      : begin
  3042.       cursorsavex := cursorx;
  3043.       cursorsavey := cursory;
  3044.     end;
  3045.     eRestoreCursorPos   : begin
  3046.       cursorx := cursorsavex;
  3047.       cursory := cursorsavey;
  3048.     end;
  3049.   end;
  3050. end;
  3051.  
  3052. Procedure RipObj.DispChar(c:char);
  3053. begin
  3054.   if (cursorx = TextX1) and textwrap then
  3055.   begin
  3056.     if (cursory <> TextY1) then
  3057.     begin
  3058.       cursorx := TextX0;
  3059.       inc(cursory);
  3060.     end;
  3061.   end;
  3062.   seek(textfontfile,byte(c));              {scrolling on y!}
  3063.   read(textfontfile,textchar);
  3064.   if c in [#0,#7,#8,#10,#12,#13,#255] then
  3065.   begin
  3066.     if c = #13 then
  3067.     begin
  3068.       cursorx := textx0;
  3069. {      if cursory < texty1 then
  3070.         inc(cursory);}
  3071.     end;
  3072.     if c = #10 then
  3073.       if cursory < texty1 then
  3074.         inc(cursory);
  3075.     if c = #8 then
  3076.     begin
  3077.       if cursorx > textx0 then
  3078.         dec(cursorx);
  3079.     end;
  3080.   end
  3081.   else
  3082.   begin
  3083.     {$IFDEF MOUSE}
  3084.     MouseOff;
  3085.     {$ENDIF}
  3086.     DisplayChar(TextOffsetX[textsize]*cursorx,TextOffsetY[textsize]*cursory,textclr and $0F,(textclr and $F0) shr 4,
  3087.                 textchar,textsize);
  3088.     {$IFDEF MOUSE}
  3089.     MouseOn;
  3090.     {$ENDIF}
  3091.   end;
  3092.   virtualwindow[cursorx,cursory,0] := byte(c);
  3093.   virtualwindow[cursorx,cursory,1] := textclr;
  3094.   if (cursorx <> textx1) and not (c in [#0,#7,#8,#10,#12,#13,#255]) then
  3095.     inc(cursorx);
  3096. end;
  3097.  
  3098. Begin
  3099.   DoNada;
  3100.   Registered := false;
  3101.   UnregDelay := true;
  3102. End.
  3103.